Altera FPGA firmware download module.

From: Igor M . Liplianin
Date: Mon May 24 2010 - 06:09:23 EST

Next message: Takashi Iwai: "[PATCH] input: Add multi-touch protocol support to Synaptics"
Messages sorted by: [ date ] [ thread ] [ subject ] [ author ]

It uses STAPL files and programs Altera FPGA through JTAG.
Interface to JTAG must be provided from main device module,
for example through cx23885 GPIO.

Signed-off-by: Igor M. Liplianin <liplianin@xxxxxxxx>
Signed-off-by: Mauro Carvalho Chehab <mchehab@xxxxxxxxxx>
---
drivers/misc/Kconfig | 1 +
drivers/misc/Makefile | 1 +
drivers/misc/stapl-altera/Kconfig | 8 +
drivers/misc/stapl-altera/Makefile | 3 +
drivers/misc/stapl-altera/altera.c | 2739 ++++++++++++++++++++++++++++++++++
drivers/misc/stapl-altera/jbicomp.c | 163 ++
drivers/misc/stapl-altera/jbiexprt.h | 94 ++
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, 4249 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..9628d9c
--- /dev/null
+++ b/drivers/misc/stapl-altera/altera.c
@@ -0,0 +1,2739 @@
+/*
+ * altera.c
+ *
+ * altera FPGA driver
+ *
+ * Copyright (C) Altera Corporation 1998-2001
+ * Copyright (C) 2010 NetUP Inc.
+ * Copyright (C) 2010 Igor M. Liplianin <liplianin@xxxxxxxx>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ *
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include <linux/firmware.h>
+#include <linux/slab.h>
+#include <misc/altera.h>
+#include "jbiexprt.h"
+
+static int verbose = 1;
+module_param(verbose, int, 0644);
+MODULE_PARM_DESC(verbose, "enable debugging information");
+
+MODULE_DESCRIPTION("altera FPGA kernel module");
+MODULE_AUTHOR("Igor M. Liplianin <liplianin@xxxxxxxx>");
+MODULE_LICENSE("GPL");
+
+#include "jbijtag.h"
+
+#define JBI_STACK_SIZE 128
+
+#define JBIC_MESSAGE_LENGTH 1024
+
+/* This macro checks if a code address is inside the code section */
+#define CHECK_PC \
+ if ((pc < code_section) || (pc >= debug_section)) { \
+ status = JBIC_BOUNDS_ERROR; \
+ }
+
+#define dprintk(args...) \
+ if (verbose) { \
+ printk(KERN_DEBUG args); \
+ }
+
+char *error_text[] = {
+ /* JBIC_SUCCESS 0 */ "success",
+ /* JBIC_OUT_OF_MEMORY 1 */ "out of memory",
+ /* JBIC_IO_ERROR 2 */ "file access error",
+ /* JAMC_SYNTAX_ERROR 3 */ "syntax error",
+ /* JBIC_UNEXPECTED_END 4 */ "unexpected end of file",
+ /* JBIC_UNDEFINED_SYMBOL 5 */ "undefined symbol",
+ /* JAMC_REDEFINED_SYMBOL 6 */ "redefined symbol",
+ /* JBIC_INTEGER_OVERFLOW 7 */ "integer overflow",
+ /* JBIC_DIVIDE_BY_ZERO 8 */ "divide by zero",
+ /* JBIC_CRC_ERROR 9 */ "CRC mismatch",
+ /* JBIC_INTERNAL_ERROR 10 */ "internal error",
+ /* JBIC_BOUNDS_ERROR 11 */ "bounds error",
+ /* JAMC_TYPE_MISMATCH 12 */ "type mismatch",
+ /* JAMC_ASSIGN_TO_CONST 13 */ "assignment to constant",
+ /* JAMC_NEXT_UNEXPECTED 14 */ "NEXT unexpected",
+ /* JAMC_POP_UNEXPECTED 15 */ "POP unexpected",
+ /* JAMC_RETURN_UNEXPECTED 16 */ "RETURN unexpected",
+ /* JAMC_ILLEGAL_SYMBOL 17 */ "illegal symbol name",
+ /* JBIC_VECTOR_MAP_FAILED 18 */ "vector signal name not found",
+ /* JBIC_USER_ABORT 19 */ "execution cancelled",
+ /* JBIC_STACK_OVERFLOW 20 */ "stack overflow",
+ /* JBIC_ILLEGAL_OPCODE 21 */ "illegal instruction code",
+ /* JAMC_PHASE_ERROR 22 */ "phase error",
+ /* JAMC_SCOPE_ERROR 23 */ "scope error",
+ /* JBIC_ACTION_NOT_FOUND 24 */ "action not found",
+};
+
+#define MAX_ERROR_CODE (int)((sizeof(error_text)/sizeof(error_text[0]))+1)
+
+/* 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 = JBIC_STACK_OVERFLOW;
+ return 0;
+ }
+
+ return 1;
+}
+
+static int jbi_strlen(char *string)
+{
+ int len = 0;
+
+ while (string[len] != '\0')
+ ++len;
+
+ return len;
+}
+
+static void jbi_ltoa(char *buffer, s32 number)
+{
+ int index = 0;
+ int rev_index = 0;
+ char reverse[32];
+
+ if (number < 0L) {
+ buffer[index++] = '-';
+ number = 0 - number;
+ } else if (number == 0)
+ buffer[index++] = '0';
+
+ while (number != 0) {
+ reverse[rev_index++] = (char)((number % 10) + '0');
+ number /= 10;
+ }
+
+ while (rev_index > 0)
+ buffer[index++] = reverse[--rev_index];
+
+ buffer[index] = '\0';
+}
+
+static char jbi_toupper(char ch)
+{
+ return (char)(((ch >= 'a') && (ch <= 'z')) ? (ch + 'A' - 'a') : ch);
+}
+
+static int jbi_stricmp(char *left, char *right)
+{
+ int result = 0;
+ char l, r;
+
+ do {
+ l = jbi_toupper(*left);
+ r = jbi_toupper(*right);
+ result = l - r;
+ ++left;
+ ++right;
+ } while ((result == 0) && (l != '\0') && (r != '\0'));
+
+ return result;
+}
+
+static void jbi_strncpy(char *left, char *right, int count)
+{
+ char ch;
+
+ do {
+ *left = *right;
+ ch = *right;
+ ++left;
+ ++right;
+ --count;
+ } while ((ch != '\0') && (count != 0));
+}
+
+static void jbi_make_dword(u8 *buf, u32 num)
+{
+ buf[0] = (u8) num;
+ buf[1] = (u8)(num >> 8L);
+ buf[2] = (u8)(num >> 16L);
+ buf[3] = (u8)(num >> 24L);
+}
+
+static u32 jbi_get_dword(u8 *buf)
+{
+ return
+ (((u32)buf[0]) |
+ (((u32)buf[1]) << 8L) |
+ (((u32)buf[2]) << 16L) |
+ (((u32)buf[3]) << 24L));
+}
+
+static void jbi_export_integer(char *key, s32 value)
+{
+ dprintk("Export: key = \"%s\", value = %d\n", key, value);
+}
+
+#define HEX_LINE_CHARS 72
+#define HEX_LINE_BITS (HEX_LINE_CHARS * 4)
+
+static char conv_to_hex(u32 value)
+{
+ char c;
+
+ if (value > 9)
+ c = (char)(value + ('A' - 10));
+ else
+ c = (char)(value + '0');
+
+ return c;
+}
+
+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 = \"%s\", %d bits, value = HEX\n",
+ key, count);
+ lines = (count + (HEX_LINE_BITS - 1)) / HEX_LINE_BITS;
+
+ for (line = 0; line < lines; ++line) {
+ if (line < (lines - 1)) {
+ linebits = HEX_LINE_BITS;
+ size = HEX_LINE_CHARS;
+ offset = count - ((line + 1) * HEX_LINE_BITS);
+ } else {
+ linebits =
+ count - ((lines - 1) * HEX_LINE_BITS);
+ size = (linebits + 3) / 4;
+ offset = 0L;
+ }
+
+ string[size] = '\0';
+ j = size - 1;
+ value = 0;
+
+ for (k = 0; k < linebits; ++k) {
+ i = k + offset;
+ if (data[i >> 3] & (1 << (i & 7)))
+ value |= (1 << (i & 3));
+ if ((i & 3) == 3) {
+ string[j] = conv_to_hex(value);
+ value = 0;
+ --j;
+ }
+ }
+ if ((k & 3) > 0)
+ string[j] = conv_to_hex(value);
+
+ dprintk("%s\n", string);
+ }
+
+ } else {
+ size = (count + 3) / 4;
+ string[size] = '\0';
+ j = size - 1;
+ value = 0;
+
+ for (i = 0; i < count; ++i) {
+ if (data[i >> 3] & (1 << (i & 7)))
+ value |= (1 << (i & 3));
+ if ((i & 3) == 3) {
+ string[j] = conv_to_hex(value);
+ value = 0;
+ --j;
+ }
+ }
+ if ((i & 3) > 0)
+ string[j] = conv_to_hex(value);
+
+ dprintk("Export: key = \"%s\", %d bits, value = HEX %s\n",
+ key, count, string);
+ }
+}
+
+static JBI_RETURN_TYPE jbi_execute(struct altera_config *astate,
+ u8 *program,
+ s32 program_size,
+ s32 *error_address,
+ int *exit_code,
+ int *format_version)
+{
+ static char message_buffer[JBIC_MESSAGE_LENGTH + 1];
+ static long stack[JBI_STACK_SIZE] = {0L};/*64 bits*/
+ JBI_RETURN_TYPE status = JBIC_SUCCESS;
+ u32 first_word = 0L;
+ u32 action_table = 0L;
+ u32 proc_table = 0L;
+ u32 string_table = 0L;
+ u32 symbol_table = 0L;
+ u32 data_section = 0L;
+ u32 code_section = 0L;
+ u32 debug_section = 0L;
+ u32 action_count = 0L;
+ u32 proc_count = 0L;
+ u32 symbol_count = 0L;
+ long *variables = NULL;/*64bits*/
+ s32 *variable_size = NULL;
+ char *attributes = 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*/
+ 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 uncompressed_size;
+ u32 offset;
+ u32 value;
+ int current_proc = 0;
+ int reverse;
+
+ char *name;
+
+ dprintk("%s\n", __func__);
+
+ /* Read header information */
+ if (program_size > 52L) {
+ first_word = GET_DWORD(0);
+ version = (int)(first_word & 1L);
+ *format_version = version + 1;
+ delta = version * 8;
+
+ action_table = GET_DWORD(4);
+ proc_table = GET_DWORD(8);
+ string_table = GET_DWORD(4 + delta);
+ symbol_table = GET_DWORD(16 + delta);
+ data_section = GET_DWORD(20 + delta);
+ code_section = GET_DWORD(24 + delta);
+ debug_section = GET_DWORD(28 + delta);
+ action_count = GET_DWORD(40 + delta);
+ proc_count = GET_DWORD(44 + delta);
+ symbol_count = GET_DWORD(48 + (2 * delta));
+ }
+
+ if ((first_word != 0x4A414D00L) && (first_word != 0x4A414D01L)) {
+ done = 1;
+ status = JBIC_IO_ERROR;
+ goto exit_done;
+ }
+
+ if (symbol_count <= 0)
+ goto exit_done;
+ /* 64 bits */
+ variables = kmalloc((u32)symbol_count * sizeof(long), GFP_KERNEL);
+
+ if (variables == NULL)
+ status = JBIC_OUT_OF_MEMORY;
+
+ if (status == JBIC_SUCCESS) {
+ variable_size = kmalloc(
+ (u32)symbol_count * sizeof(s32), GFP_KERNEL);
+
+ if (variable_size == NULL)
+ status = JBIC_OUT_OF_MEMORY;
+ }
+
+ if (status == JBIC_SUCCESS) {
+ attributes = (char *)
+ kmalloc((u32)symbol_count, GFP_KERNEL);
+
+ if (attributes == NULL)
+ status = JBIC_OUT_OF_MEMORY;
+ }
+
+ if ((status == JBIC_SUCCESS) && (version > 0)) {
+ proc_attributes = (u8 *)
+ kmalloc((u32)proc_count, GFP_KERNEL);
+
+ if (proc_attributes == NULL)
+ status = JBIC_OUT_OF_MEMORY;
+ }
+
+ if (status != JBIC_SUCCESS)
+ goto exit_done;
+
+ delta = version * 2;
+
+ for (i = 0; i < (u32)symbol_count; ++i) {
+ offset = (u32)
+ (symbol_table + ((11 + delta) * i));
+
+ value = GET_DWORD(offset + 3 + delta);
+
+ attributes[i] = GET_BYTE(offset);
+
+ /* use bit 7 of attribute byte to indicate that
+ this buffer was dynamically allocated
+ and should be freed later */
+ attributes[i] &= 0x7f;
+
+ variable_size[i] = GET_DWORD(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 ((attributes[i] & 0x0c) == 0x04)
+ /* initialized scalar variable */
+ variables[i] = value;
+ else if ((attributes[i] & 0x1e) == 0x0e) {
+ /* initialized compressed
+ Boolean array */
+ uncompressed_size = jbi_get_dword(
+ &program[data_section + value]);
+
+ /* allocate a buffer for the
+ uncompressed data */
+ variables[i] = (long)kmalloc(uncompressed_size,
+ GFP_KERNEL);
+ dprintk("%s: var=%lx, (s32)var=%x\n", __func__,
+ variables[i], (s32)variables[i]);
+ if (variables[i] == 0L)
+ status = JBIC_OUT_OF_MEMORY;
+ else {
+ /* set flag so buffer
+ will be freed later */
+ attributes[i] |= 0x80;
+
+ /* uncompress the data */
+ if (jbi_uncompress(&program[data_section +
+ value],
+ variable_size[i],
+ (u8 *)variables[i],/*64 bits*/
+ uncompressed_size,
+ version) != uncompressed_size)
+ /* decompression failed */
+ status = JBIC_IO_ERROR;
+ else /*64 bits?*/
+ variable_size[i] =
+ uncompressed_size * 8L;
+
+ }
+ } else if ((attributes[i] & 0x1e) == 0x0c) {
+ /* initialized Boolean array */
+ /*64 bits*/
+ variables[i] = value + data_section + (long)program;
+ } else if ((attributes[i] & 0x1c) == 0x1c) {
+ /* initialized integer array */
+ variables[i] = value + data_section;
+ } else if ((attributes[i] & 0x0c) == 0x08) {
+ /* uninitialized array */
+
+ /* flag attributes so
+ that memory is freed */
+ attributes[i] |= 0x80;
+
+ if (variable_size[i] > 0) {
+ u32 size;
+
+ if (attributes[i] & 0x10)
+ /* integer array */
+ size = (u32)(variable_size[i] *
+ sizeof(s32));
+ else
+ /* Boolean array */
+ size = (u32)
+ ((variable_size[i] + 7L) / 8L);
+ /*64 bits*/
+ variables[i] = (long)kmalloc(size, GFP_KERNEL);
+
+ if (variables[i] == 0) {
+ status = JBIC_OUT_OF_MEMORY;
+ } else {
+ /* zero out memory */
+ for (j = 0; j < size; ++j)
+ /*64 bits*/
+ ((u8 *)(variables[i]))[j] = 0;
+
+ }
+ } else
+ variables[i] = 0;
+
+ } else
+ variables[i] = 0;
+
+ }
+
+exit_done:
+ if (status != JBIC_SUCCESS)
+ done = 1;
+
+ jbi_init_jtag();
+
+ pc = code_section;
+ message_buffer[0] = '\0';
+
+ /*
+ For JBC version 2, we will execute the procedures corresponding to
+ the selected ACTION */
+ if (version > 0) {
+ if (astate->action == NULL) {
+ status = JBIC_ACTION_NOT_FOUND;
+ done = 1;
+ } else {
+ int action_found = 0;
+ for (i = 0; (i < action_count) && !action_found; ++i) {
+ name_id = GET_DWORD(action_table + (12 * i));
+
+ name = (char *)&program[string_table + name_id];
+
+ if (jbi_stricmp(astate->action, name) == 0) {
+ action_found = 1;
+ current_proc = (int)
+ GET_DWORD(action_table +
+ (12 * i) + 8);
+ }
+ }
+
+ if (!action_found) {
+ status = JBIC_ACTION_NOT_FOUND;
+ done = 1;
+ }
+ }
+
+ if (status == JBIC_SUCCESS) {
+ int first_time = 1;
+ i = current_proc;
+ while ((i != 0) || first_time) {
+ first_time = 0;
+ /* check procedure attribute byte */
+ proc_attributes[i] = (u8)
+ (GET_BYTE(proc_table +
+ (13 * i) + 8) &
+ 0x03);
+
+ /*
+ BIT0 - OPTIONAL
+ BIT1 - RECOMMENDED
+ BIT6 - FORCED OFF
+ BIT7 - FORCED ON
+ */
+
+ i = (u32)GET_DWORD(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_DWORD(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_section +
+ GET_DWORD(proc_table + (13 * i) + 9);
+ CHECK_PC;
+ } else
+ /* there are no procedures to execute! */
+ done = 1;
+
+ }
+ }
+
+ message_buffer[0] = '\0';
+
+ while (!done) {
+ opcode = (u32)(GET_BYTE(pc) & 0xff);
+ opcode_address = pc;
+ ++pc;
+
+ if (verbose > 1)
+ printk("opcode: %02x\n", opcode);
+
+ arg_count = (opcode >> 6) & 3;
+ for (i = 0; i < arg_count; ++i) {
+ args[i] = GET_DWORD(pc);
+ pc += 4;
+ }
+
+ switch (opcode) {
+ case 0x00: /* NOP */
+ break;
+ case 0x01: /* DUP */
+ if (jbi_check_stack(stack_ptr, 1, &status)) {
+ stack[stack_ptr] = stack[stack_ptr - 1];
+ ++stack_ptr;
+ }
+ break;
+ case 0x02: /* 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 0x03: /* ADD */
+ if (jbi_check_stack(stack_ptr, 2, &status)) {
+ --stack_ptr;
+ stack[stack_ptr - 1] += stack[stack_ptr];
+ }
+ break;
+ case 0x04: /* SUB */
+ if (jbi_check_stack(stack_ptr, 2, &status)) {
+ --stack_ptr;
+ stack[stack_ptr - 1] -= stack[stack_ptr];
+ }
+ break;
+ case 0x05: /* MULT */
+ if (jbi_check_stack(stack_ptr, 2, &status)) {
+ --stack_ptr;
+ stack[stack_ptr - 1] *= stack[stack_ptr];
+ }
+ break;
+ case 0x06: /* DIV */
+ if (jbi_check_stack(stack_ptr, 2, &status)) {
+ --stack_ptr;
+ stack[stack_ptr - 1] /= stack[stack_ptr];
+ }
+ break;
+ case 0x07: /* MOD */
+ if (jbi_check_stack(stack_ptr, 2, &status)) {
+ --stack_ptr;
+ stack[stack_ptr - 1] %= stack[stack_ptr];
+ }
+ break;
+ case 0x08: /* SHL */
+ if (jbi_check_stack(stack_ptr, 2, &status)) {
+ --stack_ptr;
+ stack[stack_ptr - 1] <<= stack[stack_ptr];
+ }
+ break;
+ case 0x09: /* SHR */
+ if (jbi_check_stack(stack_ptr, 2, &status)) {
+ --stack_ptr;
+ stack[stack_ptr - 1] >>= stack[stack_ptr];
+ }
+ break;
+ case 0x0A: /* NOT */
+ if (jbi_check_stack(stack_ptr, 1, &status))
+ stack[stack_ptr - 1] ^= (-1L);
+
+ break;
+ case 0x0B: /* AND */
+ if (jbi_check_stack(stack_ptr, 2, &status)) {
+ --stack_ptr;
+ stack[stack_ptr - 1] &= stack[stack_ptr];
+ }
+ break;
+ case 0x0C: /* OR */
+ if (jbi_check_stack(stack_ptr, 2, &status)) {
+ --stack_ptr;
+ stack[stack_ptr - 1] |= stack[stack_ptr];
+ }
+ break;
+ case 0x0D: /* XOR */
+ if (jbi_check_stack(stack_ptr, 2, &status)) {
+ --stack_ptr;
+ stack[stack_ptr - 1] ^= stack[stack_ptr];
+ }
+ break;
+ case 0x0E: /* INV */
+ if (!jbi_check_stack(stack_ptr, 1, &status))
+ break;
+ stack[stack_ptr - 1] = stack[stack_ptr - 1] ? 0L : 1L;
+ break;
+ case 0x0F: /* 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 0x10: /* 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 0x11: /* 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_DWORD(proc_table +
+ (13 * current_proc) + 4);
+ while ((i != 0) &&
+ ((proc_attributes[i] == 1) ||
+ ((proc_attributes[i] & 0xc0) == 0x40)))
+ i = (u32)
+ GET_DWORD(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_section +
+ GET_DWORD(proc_table +
+ (13 * i) + 9);
+ CHECK_PC;
+ }
+
+ } else
+ if (jbi_check_stack(stack_ptr, 1, &status)) {
+ pc = stack[--stack_ptr] + code_section;
+ CHECK_PC;
+ if (pc == code_section)
+ status = JBIC_BOUNDS_ERROR;
+
+ }
+
+ break;
+ case 0x12: /* 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 = JBIC_BOUNDS_ERROR;
+ else {
+ long_temp &= ((-1L) >> (32 - count));
+
+ stack[stack_ptr - 1] =
+ ((a & long_temp) == (b & long_temp))
+ ? 1L : 0L;
+ }
+ }
+ break;
+ case 0x13: /* PINT */
+ /*
+ PRINT add integer
+ ...stack 0 is integer value
+ */
+ if (!jbi_check_stack(stack_ptr, 1, &status))
+ break;
+ jbi_ltoa(&message_buffer[jbi_strlen(message_buffer)],
+ stack[--stack_ptr]);
+ break;
+ case 0x14: /* PRNT */
+ /* PRINT finish */
+ if (verbose)
+ printk(message_buffer, "\n");
+
+ message_buffer[0] = '\0';
+ break;
+ case 0x15: /* 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];
+ jbi_make_dword(charbuf, long_temp);
+ status = jbi_do_drscan(astate, count, charbuf, 0);
+ break;
+ case 0x16: /* 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];
+ jbi_make_dword(charbuf, long_temp);
+ status = jbi_swap_dr(astate, count, charbuf,
+ 0, charbuf, 0);
+ stack[stack_ptr - 1] = jbi_get_dword(charbuf);
+ break;
+ case 0x17: /* 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];
+ jbi_make_dword(charbuf, long_temp);
+ status = jbi_do_irscan(astate, count, charbuf, 0);
+ break;
+ case 0x18: /* 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];
+ jbi_make_dword(charbuf, long_temp);
+ status = jbi_swap_ir(astate, count, charbuf,
+ 0, charbuf, 0);
+ stack[stack_ptr - 1] = jbi_get_dword(charbuf);
+ break;
+ case 0x19: /* VSS */
+ /*
+ VECTOR short
+ ...stack 0 is scan data
+ ...stack 1 is count
+ */
+ bad_opcode = 1;
+ break;
+ case 0x1A: /* VSSC */
+ /*
+ VECTOR short with capture
+ ...stack 0 is scan data
+ ...stack 1 is count
+ */
+ bad_opcode = 1;
+ break;
+ case 0x1B: /* VMPF */
+ /* VMAP finish */
+ bad_opcode = 1;
+ break;
+ case 0x1C: /* 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 0x1D: /* 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];
+ jbi_make_dword(charbuf, long_temp);
+ status = jbi_set_dr_preamble(count, 0, charbuf);
+ break;
+ case 0x1E: /* 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 0x1F: /* 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];
+ jbi_make_dword(charbuf, long_temp);
+ status = jbi_set_dr_postamble(count, 0, charbuf);
+ break;
+ case 0x20: /* IPR */
+ if (jbi_check_stack(stack_ptr, 1, &status)) {
+ count = (u32)stack[--stack_ptr];
+ status = jbi_set_ir_preamble(count, 0, NULL);
+ }
+ break;
+ case 0x21: /* 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];
+ jbi_make_dword(charbuf, long_temp);
+ status = jbi_set_ir_preamble(count, 0, charbuf);
+ }
+ break;
+ case 0x22: /* 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 0x23: /* 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];
+ jbi_make_dword(charbuf, long_temp);
+ status = jbi_set_ir_postamble(count, 0, charbuf);
+ break;
+ case 0x24: /* PCHR */
+ if (jbi_check_stack(stack_ptr, 1, &status)) {
+ u8 ch;
+ count = jbi_strlen(message_buffer);
+ 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;
+ }
+ message_buffer[count] = ch;
+ message_buffer[count + 1] = '\0';
+ }
+ break;
+ case 0x25: /* EXIT */
+ if (jbi_check_stack(stack_ptr, 1, &status))
+ *exit_code = (int) stack[--stack_ptr];
+
+ done = 1;
+ break;
+ case 0x26: /* 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 0x27: /* POPT */
+ if (jbi_check_stack(stack_ptr, 1, &status))
+ --stack_ptr;
+
+ break;
+ case 0x28: /* TRST */
+ bad_opcode = 1;
+ break;
+
+ case 0x29: /* FRQ */
+ bad_opcode = 1;
+ break;
+ case 0x2A: /* FRQU */
+ bad_opcode = 1;
+ break;
+ case 0x2B: /* PD32 */
+ bad_opcode = 1;
+ break;
+ case 0x2C: /* 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 0x2D: /* 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 0x2E: /* BCH1 */
+ /*
+ Batch operation 1
+ SWPN 8
+ SWP
+ SWPN 9
+ SWPN 3
+ SWP
+ SWPN 2
+ SWP
+ SWPN 7
+ SWP
+ SWPN 6
+ DUPN 5
+ DUPN 5
+ */
+ bad_opcode = 1;
+ break;
+ case 0x2F: /* PSH0 */
+ stack[stack_ptr++] = 0;
+ break;
+ case 0x40: /* PSHL */
+ stack[stack_ptr++] = (s32) args[0];
+ break;
+ case 0x41: /* PSHV */
+ stack[stack_ptr++] = variables[args[0]];
+ break;
+ case 0x42: /* JMP */
+ pc = args[0] + code_section;
+ CHECK_PC;
+ break;
+ case 0x43: /* CALL */
+ stack[stack_ptr++] = pc;
+ pc = args[0] + code_section;
+ CHECK_PC;
+ break;
+ case 0x44: /* 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 = variables[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 {
+ variables[args[0]] = iterator + step;
+ pc = top + code_section;
+ CHECK_PC;
+ }
+ }
+ break;
+ case 0x45: /* PSTR */
+ /*
+ PRINT add string
+ ...argument 0 is string ID
+ */
+ count = jbi_strlen(message_buffer);
+ jbi_strncpy(&message_buffer[count],
+ (char *)&program[string_table + args[0]],
+ JBIC_MESSAGE_LENGTH - count);
+ message_buffer[JBIC_MESSAGE_LENGTH] = '\0';
+ break;
+ case 0x46: /* VMAP */
+ /*
+ VMAP add signal name
+ ...argument 0 is string ID
+ */
+ bad_opcode = 1;
+ break;
+ case 0x47: /* SINT */
+ /*
+ STATE intermediate state
+ ...argument 0 is state code
+ */
+ status = jbi_goto_jtag_state(astate, (int) args[0]);
+ break;
+ case 0x48: /* ST */
+ /*
+ STATE final state
+ ...argument 0 is state code
+ */
+ status = jbi_goto_jtag_state(astate, (int) args[0]);
+ break;
+ case 0x49: /* ISTP */
+ /*
+ IRSTOP state
+ ...argument 0 is state code
+ */
+ status = jbi_set_irstop_state((int) args[0]);
+ break;
+ case 0x4A: /* DSTP */
+ /*
+ DRSTOP state
+ ...argument 0 is state code
+ */
+ status = jbi_set_drstop_state((int) args[0]);
+ break;
+
+ case 0x4B: /* 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 0x4C: /* 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 0x4D: /* POPV */
+ /*
+ * Pop stack into scalar variable
+ ...argument 0 is variable ID
+ ...stack 0 is value
+ */
+ if (jbi_check_stack(stack_ptr, 1, &status))
+ variables[args[0]] = stack[--stack_ptr];
+
+ break;
+ case 0x4E: /* 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) &&
+ ((attributes[variable_id] & 0x9c) == 0x1c)) {
+ /* Allocate a writable buffer for this array */
+ count = (u32)variable_size[variable_id];
+ long_temp = variables[variable_id];
+ /*64 bits*/
+ longptr_temp = (long *)
+ kmalloc(count * sizeof(long),
+ GFP_KERNEL);
+ /*64 bits*/
+ variables[variable_id] = (long)longptr_temp;
+
+ if (variables[variable_id] == 0) {
+ status = JBIC_OUT_OF_MEMORY;
+ break;
+ }
+
+ /* copy previous contents into buffer */
+ for (i = 0; i < count; ++i) {
+ /*64 QWORD?*/
+ longptr_temp[i] = GET_DWORD(long_temp);
+ long_temp += sizeof(long);/*64*/
+ }
+
+ /*
+ set bit 7 - buffer was
+ dynamically allocated */
+ attributes[variable_id] |= 0x80;
+
+ /* clear bit 2 - variable is writable */
+ attributes[variable_id] &= ~0x04;
+ attributes[variable_id] |= 0x01;
+
+ }
+
+ /* check that variable is a writable integer array */
+ if ((attributes[variable_id] & 0x1c) != 0x18)
+ status = JBIC_BOUNDS_ERROR;
+ else {
+ /*64 bits*/
+ longptr_temp = (long *)variables[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 0x4F: /* 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) &&
+ ((attributes[variable_id] & 0x9c) == 0x0c)) {
+ /* Allocate a writable buffer for this array */
+ long_temp =
+ (variable_size[variable_id] + 7L) >> 3L;
+ charptr_temp2 = (u8 *)variables[variable_id];
+ charptr_temp =
+ kmalloc((u32)long_temp, GFP_KERNEL);
+ /*64 bits*/
+ variables[variable_id] = (long)charptr_temp;
+
+ if (variables[variable_id] == 0) {
+ status = JBIC_OUT_OF_MEMORY;
+ 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 < variable_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 */
+ attributes[variable_id] |= 0x80;
+
+ /* clear bit 2 - variable is writable */
+ attributes[variable_id] &= ~0x04;
+ attributes[variable_id] |= 0x01;
+
+ }
+
+ /*
+ check that variable is
+ a writable Boolean array */
+ if ((attributes[variable_id] & 0x1c) != 0x08) {
+ status = JBIC_BOUNDS_ERROR;
+ break;
+ }
+
+ charptr_temp = (u8 *)variables[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 = JBIC_BOUNDS_ERROR;
+ break;
+ } else
+ long_count = 1 + long_count -
+ long_index;
+
+ }
+
+ /* pop the data */
+ long_temp = stack[--stack_ptr];
+
+ if (long_count < 1) {
+ status = JBIC_BOUNDS_ERROR;
+ 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 0x50: /* 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_section;
+ CHECK_PC;
+ }
+ }
+ break;
+ case 0x51: /* DS */
+ case 0x52: /* 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 *)variables[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 = JBIC_OUT_OF_MEMORY;
+ 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 0x53: /* 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 *)variables[args[0]];
+ status = jbi_set_dr_preamble(count, index,
+ charptr_temp);
+ break;
+ case 0x54: /* 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 *)variables[args[0]];
+ status = jbi_set_dr_postamble(count, index,
+ charptr_temp);
+ break;
+ case 0x55: /* 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 *)variables[args[0]];
+ status = jbi_set_ir_preamble(count, index,
+ charptr_temp);
+
+ break;
+ case 0x56: /* 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 *)variables[args[0]];
+ status = jbi_set_ir_postamble(count, index,
+ charptr_temp);
+
+ break;
+ case 0x57: /* EXPT */
+ /*
+ EXPORT
+ ...argument 0 is string ID
+ ...stack 0 is integer expression
+ */
+ if (jbi_check_stack(stack_ptr, 1, &status)) {
+ name = (char *)&program[string_table + args[0]];
+ long_temp = stack[--stack_ptr];
+ jbi_export_integer(name, long_temp);
+ }
+ break;
+ case 0x58: /* 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 ((attributes[variable_id] & 0x1f) == 0x19) {
+ /* writable integer array */
+ longptr_temp = (long *)variables[variable_id];
+ stack[stack_ptr - 1] = longptr_temp[index];
+ } else if ((attributes[variable_id] & 0x1f) == 0x1c) {
+ /* read-only integer array */
+ long_temp = variables[variable_id] +
+ (sizeof(long) * index);/*64*/
+ stack[stack_ptr - 1] = GET_DWORD(long_temp);
+ } else
+ status = JBIC_BOUNDS_ERROR;
+
+ break;
+ case 0x59: /* 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 ((attributes[variable_id] & 0x18) != 0x08) {
+ status = JBIC_BOUNDS_ERROR;
+ break;
+ }
+
+ charptr_temp = (u8 *)variables[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 = JBIC_BOUNDS_ERROR;
+ 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 0x5A: /* 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 > variable_size[variable_id]) {
+ variable_size[variable_id] = long_temp;
+
+ if (attributes[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 ((attributes[variable_id] & 0x80) &&
+ (variables[variable_id] != 0)) {
+ kfree((void *)variables[variable_id]);
+ variables[variable_id] = 0;
+ }
+
+ /*
+ Allocate a new buffer
+ of the requested size */
+ /*64 bits*/
+ variables[variable_id] = (long)
+ kmalloc((u32)long_temp, GFP_KERNEL);
+
+ if (variables[variable_id] == 0) {
+ status = JBIC_OUT_OF_MEMORY;
+ break;
+ }
+
+ /*
+ Set the attribute bit to indicate that
+ this buffer was dynamically allocated and
+ should be freed later */
+ attributes[variable_id] |= 0x80;
+
+ /* zero out memory */
+ count = (u32)
+ ((variable_size[variable_id] + 7L) /
+ 8L);
+ charptr_temp = (u8 *)(variables[variable_id]);
+ for (index = 0; index < count; ++index)
+ charptr_temp[index] = 0;
+
+ }
+
+ break;
+ case 0x5B: /* EXPR */
+ bad_opcode = 1;
+ break;
+ case 0x5C: /* 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 *)&program[string_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 = JBIC_BOUNDS_ERROR;
+ break;
+ }
+
+ long_count = 1 + long_index2 - long_index;
+
+ charptr_temp = (u8 *)variables[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 = JBIC_OUT_OF_MEMORY;
+ 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 0x80: { /* 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 = JBIC_BOUNDS_ERROR;
+
+ }
+
+ 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) &&
+ ((attributes[variable_id] & 0x9c) == 0x0c)) {
+ /* Allocate a writable buffer for this array */
+ long_temp =
+ (variable_size[variable_id] + 7L) >> 3L;
+ charptr_temp2 = (u8 *)variables[variable_id];
+ charptr_temp =
+ kmalloc((u32)long_temp, GFP_KERNEL);
+ /*64 bits*/
+ variables[variable_id] = (long)charptr_temp;
+
+ if (variables[variable_id] == 0) {
+ status = JBIC_OUT_OF_MEMORY;
+ 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 < variable_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 */
+ attributes[variable_id] |= 0x80;
+
+ /* clear bit 2 - variable is writable */
+ attributes[variable_id] &= ~0x04;
+ attributes[variable_id] |= 0x01;
+ }
+
+ charptr_temp = (u8 *)variables[args[1]];
+ charptr_temp2 = (u8 *)variables[args[0]];
+
+ /* check that destination is a writable Boolean array */
+ if ((attributes[args[1]] & 0x1c) != 0x08) {
+ status = JBIC_BOUNDS_ERROR;
+ break;
+ }
+
+ if (count < 1) {
+ status = JBIC_BOUNDS_ERROR;
+ 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 0x81: /* REVA */
+ /*
+ ARRAY COPY reversing bit order
+ ...argument 0 is dest ID
+ ...argument 1 is source ID
+ ...stack 0 is dest index
+ ...stack 1 is source index
+ ...stack 2 is count
+ */
+ bad_opcode = 1;
+ break;
+ case 0x82: /* DSC */
+ case 0x83: { /* 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) &&
+ ((attributes[variable_id] & 0x9c) == 0x0c)) {
+ /* Allocate a writable buffer for this array */
+ long_temp =
+ (variable_size[variable_id] + 7L) >> 3L;
+ charptr_temp2 = (u8 *)variables[variable_id];
+ charptr_temp =
+ kmalloc((u32)long_temp, GFP_KERNEL);
+ variables[variable_id] = (long)charptr_temp;
+
+ if (variables[variable_id] == 0) {
+ status = JBIC_OUT_OF_MEMORY;
+ 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 < variable_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 */
+ attributes[variable_id] |= 0x80;
+
+ /* clear bit 2 - variable is writable */
+ attributes[variable_id] &= ~0x04;
+ attributes[variable_id] |= 0x01;
+
+ }
+
+ charptr_temp = (u8 *)variables[args[0]];
+ charptr_temp2 = (u8 *)variables[args[1]];
+
+ if ((version > 0) &&
+ ((long_count > capture_count) ||
+ (long_count > scan_count))) {
+ status = JBIC_BOUNDS_ERROR;
+ break;
+ }
+
+ /*
+ check that capture array
+ is a writable Boolean array */
+ if ((attributes[args[1]] & 0x1c) != 0x08) {
+ status = JBIC_BOUNDS_ERROR;
+ break;
+ }
+
+ if (status == JBIC_SUCCESS) {
+ 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 0x84: /* 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 == JBIC_SUCCESS) && (long_temp != 0L))
+ status = jbi_do_wait_microseconds(astate,
+ long_temp,
+ (u32)args[0]);
+
+ if ((status == JBIC_SUCCESS) && (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 0x85: /* VS */
+ /*
+ VECTOR
+ ...argument 0 is dir data variable ID
+ ...argument 1 is scan data variable ID
+ ...stack 0 is dir array index
+ ...stack 1 is scan array index
+ ...stack 2 is count
+ */
+ bad_opcode = 1;
+ break;
+ case 0xC0: { /* 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 *)variables[args[0]];
+ u8 *source2 = (u8 *)variables[args[1]];
+ u8 *mask = (u8 *)variables[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 = JBIC_BOUNDS_ERROR;
+ 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;
+ }
+ case 0xC1: /* VSC */
+ /*
+ VECTOR with capture
+ ...argument 0 is dir data variable ID
+ ...argument 1 is scan data variable ID
+ ...argument 2 is capture variable ID
+ ...stack 0 is capture index
+ ...stack 1 is scan data index
+ ...stack 2 is dir data index
+ ...stack 3 is count
+ */
+ bad_opcode = 1;
+ break;
+ default:
+ /* Unrecognized opcode -- ERROR! */
+ bad_opcode = 1;
+ break;
+ }
+
+ if (bad_opcode)
+ status = JBIC_ILLEGAL_OPCODE;
+
+ if ((stack_ptr < 0) || (stack_ptr >= JBI_STACK_SIZE))
+ status = JBIC_STACK_OVERFLOW;
+
+ if (status != JBIC_SUCCESS) {
+ done = 1;
+ *error_address = (s32)(opcode_address - code_section);
+ }
+ }
+
+ jbi_free_jtag_padding_buffers(astate/*, reset_jtag*/);
+
+ /* Free all dynamically allocated arrays */
+ if ((attributes != NULL) && (variables != NULL)) {
+ for (i = 0; i < (u32)symbol_count; ++i) {
+ if ((attributes[i] & 0x80) && (variables[i] != 0))
+ kfree((void *)variables[i]);
+
+ }
+ }
+
+ if (variables != NULL)
+ kfree(variables);
+
+ if (variable_size != NULL)
+ kfree(variable_size);
+
+ if (attributes != NULL)
+ kfree(attributes);
+
+ if (proc_attributes != NULL)
+ kfree(proc_attributes);
+
+ return status;
+}
+
+static JBI_RETURN_TYPE jbi_get_note(u8 *program, 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 JBIC_SUCCESS for success, else appropriate error code */
+{
+ JBI_RETURN_TYPE status = JBIC_UNEXPECTED_END;
+ 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_DWORD(0);
+ version = (int)(first_word & 1L);
+ delta = version * 8;
+
+ note_strings = GET_DWORD(8 + delta);
+ note_table = GET_DWORD(12 + delta);
+ note_count = GET_DWORD(44 + (2 * delta));
+ }
+
+ if ((first_word != 0x4A414D00L) && (first_word != 0x4A414D01L)) {
+ status = JBIC_IO_ERROR;
+ return status;
+ }
+
+ 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 != JBIC_SUCCESS); ++i) {
+ key_ptr = (char *)
+ &program[note_strings +
+ GET_DWORD(note_table + (8 * i))];
+ if ((key != NULL) && (jbi_stricmp(key, key_ptr) == 0)) {
+ status = JBIC_SUCCESS;
+
+ value_ptr = (char *)
+ &program[note_strings +
+ GET_DWORD(note_table + (8 * i) + 4)];
+
+ if (value != NULL)
+ jbi_strncpy(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 = JBIC_SUCCESS;
+
+ if (key != NULL)
+ jbi_strncpy(key,
+ (char *)&program[note_strings +
+ GET_DWORD(note_table + (8 * i))],
+ length);
+
+ if (value != NULL)
+ jbi_strncpy(value,
+ (char *)&program[note_strings +
+ GET_DWORD(note_table + (8 * i) + 4)],
+ length);
+
+ *offset = i + 1;
+ }
+ }
+
+ return status;
+}
+
+static JBI_RETURN_TYPE jbi_check_crc(u8 *program, s32 program_size)
+{
+ JBI_RETURN_TYPE status = JBIC_SUCCESS;
+ 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_DWORD(0);
+ version = (int)(first_word & 1L);
+ delta = version * 8;
+
+ crc_section = GET_DWORD(32 + delta);
+ }
+
+ if ((first_word != 0x4A414D00L) && (first_word != 0x4A414D01L))
+ status = JBIC_IO_ERROR;
+
+ if (crc_section >= (u32)program_size)
+ status = JBIC_IO_ERROR;
+
+ if (status == JBIC_SUCCESS) {
+ local_expected = (u16)GET_WORD(crc_section);
+
+ for (i = 0; i < crc_section; ++i) {
+ databyte = GET_BYTE(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 = JBIC_CRC_ERROR;
+
+ }
+
+ if (verbose || (status == JBIC_CRC_ERROR)) {
+ switch (status) {
+ case JBIC_SUCCESS:
+ printk(KERN_INFO "CRC matched: CRC value = %04X\n",
+ local_actual);
+ break;
+ case JBIC_CRC_ERROR:
+ printk(KERN_ERR "CRC mismatch: expected %04X, "
+ "actual %04X\n", local_expected, local_actual);
+ break;
+ case JBIC_UNEXPECTED_END:
+ printk(KERN_ERR "Expected CRC not found, "
+ "actual CRC = %04X\n", local_actual);
+ break;
+ case JBIC_IO_ERROR:
+ printk(KERN_ERR "Error: Format isn't recognized.\n");
+ break;
+ default:
+ printk(KERN_ERR "CRC function returned error code %d\n",
+ status);
+ break;
+ }
+ }
+
+ return status;
+}
+
+static JBI_RETURN_TYPE jbi_get_file_info(u8 *program,
+ s32 program_size,
+ int *format_version,
+ int *action_count,
+ int *procedure_count)
+{
+ JBI_RETURN_TYPE status = JBIC_IO_ERROR;
+ u32 first_word = 0;
+ int version = 0;
+
+ if (program_size <= 52L)
+ return status;
+
+ first_word = GET_DWORD(0);
+
+ if ((first_word == 0x4A414D00L) || (first_word == 0x4A414D01L)) {
+ status = JBIC_SUCCESS;
+
+ version = (int)(first_word & 1L);
+ *format_version = version + 1;
+
+ if (version > 0) {
+ *action_count = (int)GET_DWORD(48);
+ *procedure_count = (int)GET_DWORD(52);
+ }
+ }
+
+ return status;
+}
+
+static JBI_RETURN_TYPE jbi_get_action_info(u8 *program,
+ s32 program_size,
+ int index,
+ char **name,
+ char **description,
+ struct JBI_PROCINFO **procedure_list)
+{
+ JBI_RETURN_TYPE status = JBIC_IO_ERROR;
+ struct JBI_PROCINFO *procptr = NULL;
+ struct JBI_PROCINFO *tmpptr = NULL;
+ u32 first_word = 0L;
+ u32 action_table = 0L;
+ u32 proc_table = 0L;
+ u32 string_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_DWORD(0);
+
+ if (first_word != 0x4A414D01L)
+ return status;
+
+ action_table = GET_DWORD(4);
+ proc_table = GET_DWORD(8);
+ string_table = GET_DWORD(12);
+ note_strings = GET_DWORD(16);
+ action_count = GET_DWORD(48);
+ proc_count = GET_DWORD(52);
+
+ if (index >= (int)action_count)
+ return status;
+
+ act_name_id = GET_DWORD(action_table + (12 * index));
+ act_desc_id = GET_DWORD(action_table + (12 * index) + 4);
+ act_proc_id = GET_DWORD(action_table + (12 * index) + 8);
+
+ *name = (char *)&program[string_table + act_name_id];
+
+ if (act_desc_id < (note_strings - string_table))
+ *description = (char *)&program[string_table + act_desc_id];
+
+ do {
+ act_proc_name = GET_DWORD(proc_table + (13 * act_proc_id));
+ act_proc_attribute = (u8)
+ (GET_BYTE(proc_table + (13 * act_proc_id) + 8) & 0x03);
+
+ procptr = (struct JBI_PROCINFO *)
+ kmalloc(sizeof(struct JBI_PROCINFO),
+ GFP_KERNEL);
+
+ if (procptr == NULL)
+ status = JBIC_OUT_OF_MEMORY;
+ else {
+ procptr->name = (char *)
+ &program[string_table + act_proc_name];
+ procptr->attributes = act_proc_attribute;
+ procptr->next = NULL;
+
+ /* add record to end of linked list */
+ if (*procedure_list == NULL)
+ *procedure_list = procptr;
+ else {
+ tmpptr = *procedure_list;
+ while (tmpptr->next != NULL)
+ tmpptr = tmpptr->next;
+ tmpptr->next = procptr;
+ }
+ }
+
+ act_proc_id = GET_DWORD(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 *procedure_list = NULL;
+ struct JBI_PROCINFO *procptr = NULL;
+ JBI_RETURN_TYPE exec_result = JBIC_SUCCESS;
+ 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) {
+ printk(KERN_INFO "%s: using byteblaster!\n", __func__);
+ astate->jtag_io = netup_jtag_io_lpt;
+ }
+
+ jbi_check_crc((u8 *)fw->data, fw->size);
+
+ if (verbose) {
+ jbi_get_file_info((u8 *)fw->data, fw->size, &format_version,
+ &action_count, &procedure_count);
+ printk(KERN_INFO "File format is %s ByteCode format\n",
+ (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 \"%s\" = \"%s\"\n", key, value);
+ }
+
+ if (verbose && (format_version == 2) && (action_count > 0)) {
+ printk(KERN_INFO "\nActions available in this file:\n");
+ for (index = 0; index < action_count; ++index) {
+ jbi_get_action_info((u8 *)fw->data, fw->size,
+ index, &action_name,
+ &description,
+ &procedure_list);
+
+ if (description == NULL)
+ printk(KERN_INFO "%s\n", action_name);
+ else
+ printk(KERN_INFO "%s \"%s\"\n", action_name,
+ description);
+
+ procptr = procedure_list;
+ while (procptr != NULL) {
+ if (procptr->attributes != 0)
+ printk(KERN_INFO " %s (%s)\n",
+ procptr->name,
+ (procptr->attributes == 1) ?
+ "optional" : "recommended");
+
+ procedure_list = procptr->next;
+ kfree(procptr);
+ procptr = procedure_list;
+ }
+ }
+
+ printk(KERN_INFO "\n");
+ }
+
+ exec_result = jbi_execute(astate, (u8 *)fw->data, fw->size,
+ &error_address, &exit_code, &format_version);
+
+ if (exec_result == JBIC_SUCCESS) {
+ if (format_version == 2) {
+ switch (exit_code) {
+ case 0:
+ exit_string = "Success";
+ break;
+ case 1:
+ exit_string = "Checking chain failure";
+ break;
+ 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 = %d... %s\n", exit_code,
+ exit_string);
+ } else if ((format_version == 2) &&
+ (exec_result == JBIC_ACTION_NOT_FOUND)) {
+ if ((astate->action == NULL) || (*astate->action == '\0'))
+ printk(KERN_ERR "Error: no action specified for "
+ "Jam STAPL file.\nProgram terminated.\n");
+ else
+ printk(KERN_ERR "Error: action \"%s\" is not supported "
+ "for this Jam STAPL file.\n"
+ "Program terminated.\n",
+ astate->action);
+
+ } else if (exec_result < MAX_ERROR_CODE) {
+ printk(KERN_ERR "Error at address %d: %s.\n"
+ "Program terminated.\n",
+ error_address, error_text[exec_result]);
+ } else
+ printk(KERN_ERR "Unknown error code %d\n", exec_result);
+
+ if (astate != NULL) {
+ kfree(astate);
+ astate = NULL;
+ }
+
+ return 0;
+}
+EXPORT_SYMBOL(altera_init);
diff --git a/drivers/misc/stapl-altera/jbicomp.c b/drivers/misc/stapl-altera/jbicomp.c
new file mode 100644
index 0000000..5e09ec7
--- /dev/null
+++ b/drivers/misc/stapl-altera/jbicomp.c
@@ -0,0 +1,163 @@
+/*
+ * jbicomp.c
+ *
+ * altera FPGA driver
+ *
+ * Copyright (C) Altera Corporation 1998-2001
+ * Copyright (C) 2010 NetUP Inc.
+ * Copyright (C) 2010 Igor M. Liplianin <liplianin@xxxxxxxx>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ *
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include <linux/kernel.h>
+#include "jbiexprt.h"
+
+#define SHORT_BITS 16
+#define CHAR_BITS 8
+#define DATA_BLOB_LENGTH 3
+#define MATCH_DATA_LENGTH 8192
+#define JBI_ACA_REQUEST_SIZE 1024
+#define JBI_ACA_BUFFER_SIZE (MATCH_DATA_LENGTH + JBI_ACA_REQUEST_SIZE)
+
+u32 jbi_in_length = 0L;
+u32 jbi_in_index = 0L; /* byte index into compressed array */
+u32 jbi_bits_avail = CHAR_BITS;
+
+/*
+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;
+}
+
+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..351ddf3
--- /dev/null
+++ b/drivers/misc/stapl-altera/jbiexprt.h
@@ -0,0 +1,94 @@
+/*
+ * jbiexprt.h
+ *
+ * altera FPGA driver
+ *
+ * Copyright (C) Altera Corporation 1998-2001
+ * Copyright (C) 2010 NetUP Inc.
+ * Copyright (C) 2010 Igor M. Liplianin <liplianin@xxxxxxxx>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ *
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#ifndef INC_JBIEXPRT_H
+#define INC_JBIEXPRT_H
+
+/* Return codes from most JBI functions */
+
+#define JBI_RETURN_TYPE int
+
+#define JBIC_SUCCESS 0
+#define JBIC_OUT_OF_MEMORY 1
+#define JBIC_IO_ERROR 2
+/* #define JAMC_SYNTAX_ERROR 3 */
+#define JBIC_UNEXPECTED_END 4
+#define JBIC_UNDEFINED_SYMBOL 5
+/* #define JAMC_REDEFINED_SYMBOL 6 */
+#define JBIC_INTEGER_OVERFLOW 7
+#define JBIC_DIVIDE_BY_ZERO 8
+#define JBIC_CRC_ERROR 9
+#define JBIC_INTERNAL_ERROR 10
+#define JBIC_BOUNDS_ERROR 11
+/* #define JAMC_TYPE_MISMATCH 12 */
+/* #define JAMC_ASSIGN_TO_CONST 13 */
+/* #define JAMC_NEXT_UNEXPECTED 14 */
+/* #define JAMC_POP_UNEXPECTED 15 */
+/* #define JAMC_RETURN_UNEXPECTED 16 */
+/* #define JAMC_ILLEGAL_SYMBOL 17 */
+#define JBIC_VECTOR_MAP_FAILED 18
+#define JBIC_USER_ABORT 19
+#define JBIC_STACK_OVERFLOW 20
+#define JBIC_ILLEGAL_OPCODE 21
+/* #define JAMC_PHASE_ERROR 22 */
+/* #define JAMC_SCOPE_ERROR 23 */
+#define JBIC_ACTION_NOT_FOUND 24
+
+/* Macro Definitions */
+
+/* #define PROGRAM_PTR u8 *
+*/
+#define GET_BYTE(x) (program[x])
+
+#define GET_WORD(x) \
+ (((((u16) GET_BYTE(x)) << 8) & 0xFF00) | \
+ (((u16) GET_BYTE((x)+1)) & 0x00FF))
+
+#define GET_DWORD(x) \
+ (((((u32) GET_BYTE(x)) << 24L) & 0xFF000000L) | \
+ ((((u32) GET_BYTE((x)+1)) << 16L) & 0x00FF0000L) | \
+ ((((u32) GET_BYTE((x)+2)) << 8L) & 0x0000FF00L) | \
+ (((u32) GET_BYTE((x)+3)) & 0x000000FFL))
+
+/* #define GET_QWORD(x) \
+ (((((long) GET_BYTE(x)) << 56L) & 0xFF00000000000000L) | \
+ ((((long) GET_BYTE((x)+1)) << 48L) & 0xFF000000000000L) | \
+ ((((long) GET_BYTE((x)+2)) << 40L) & 0xFF0000000000L) | \
+ ((((long) GET_BYTE((x)+3)) << 32L) & 0xFF00000000L) | \
+ ((((long) GET_BYTE((x)+4)) << 24L) & 0xFF000000L) | \
+ ((((long) GET_BYTE((x)+5)) << 16L) & 0x00FF0000L) | \
+ ((((long) GET_BYTE((x)+6)) << 8L) & 0x0000FF00L) | \
+ (((long) GET_BYTE((x)+7)) & 0x000000FFL))
+*/
+struct JBI_PROCINFO {
+ char *name;
+ u8 attributes;
+ struct JBI_PROCINFO *next;
+};
+
+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..b7645e5
--- /dev/null
+++ b/drivers/misc/stapl-altera/jbijtag.c
@@ -0,0 +1,1038 @@
+/*
+ * jbijtag.c
+ *
+ * altera FPGA driver
+ *
+ * Copyright (C) Altera Corporation 1998-2001
+ * Copyright (C) 2010 NetUP Inc.
+ * Copyright (C) 2010 Igor M. Liplianin <liplianin@xxxxxxxx>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ *
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include <linux/firmware.h>
+#include <linux/slab.h>
+#include <misc/altera.h>
+#include "jbiexprt.h"
+#include "jbijtag.h"
+
+/* maximum JTAG IR and DR lengths (in bits) */
+#define JBIC_MAX_JTAG_IR_PREAMBLE 256
+#define JBIC_MAX_JTAG_IR_POSTAMBLE 256
+#define JBIC_MAX_JTAG_IR_LENGTH 512
+#define JBIC_MAX_JTAG_DR_PREAMBLE 1024
+#define JBIC_MAX_JTAG_DR_POSTAMBLE 1024
+#define JBIC_MAX_JTAG_DR_LENGTH 2048
+
+#define jbi_jtag_io(a, b, c)\
+ astate->jtag_io(astate->dev, a, b, c);
+
+#define jbi_malloc(a) kzalloc(a, GFP_KERNEL);
+
+/* Global variable to store the current JTAG state */
+enum JBIE_JTAG_STATE jbi_jtag_state = JBI_ILLEGAL_JTAG_STATE;
+
+/* Store current stop-state for DR and IR scan commands */
+enum JBIE_JTAG_STATE jbi_drstop_state = IDLE;
+enum JBIE_JTAG_STATE jbi_irstop_state = IDLE;
+
+/* Store current padding values */
+u32 jbi_dr_preamble;
+u32 jbi_dr_postamble;
+u32 jbi_ir_preamble;
+u32 jbi_ir_postamble;
+u32 jbi_dr_length;
+u32 jbi_ir_length;
+u8 *jbi_dr_preamble_data;
+u8 *jbi_dr_postamble_data;
+u8 *jbi_ir_preamble_data;
+u8 *jbi_ir_postamble_data;
+u8 *jbi_dr_buffer;
+u8 *jbi_ir_buffer;
+
+/*
+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
+};
+
+/* 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
+
+JBI_RETURN_TYPE 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 JBIC_SUCCESS;
+}
+
+JBI_RETURN_TYPE jbi_set_drstop_state(enum JBIE_JTAG_STATE state)
+{
+ jbi_drstop_state = state;
+
+ return JBIC_SUCCESS;
+}
+
+JBI_RETURN_TYPE jbi_set_irstop_state(enum JBIE_JTAG_STATE state)
+{
+ jbi_irstop_state = state;
+
+ return JBIC_SUCCESS;
+}
+
+JBI_RETURN_TYPE jbi_set_dr_preamble(u32 count, u32 start_index,
+ u8 *preamble_data)
+{
+ JBI_RETURN_TYPE status = JBIC_SUCCESS;
+ 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 = JBIC_OUT_OF_MEMORY;
+ else
+ jbi_dr_preamble = count;
+ } else
+ jbi_dr_preamble = count;
+
+ if (status == JBIC_SUCCESS) {
+ 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;
+}
+
+JBI_RETURN_TYPE jbi_set_ir_preamble(u32 count, u32 start_index,
+ u8 *preamble_data)
+{
+ JBI_RETURN_TYPE status = JBIC_SUCCESS;
+ 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 = JBIC_OUT_OF_MEMORY;
+ else
+ jbi_ir_preamble = count;
+
+ } else
+ jbi_ir_preamble = count;
+
+ if (status == JBIC_SUCCESS) {
+ 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;
+}
+
+JBI_RETURN_TYPE jbi_set_dr_postamble(u32 count, u32 start_index,
+ u8 *postamble_data)
+{
+ JBI_RETURN_TYPE status = JBIC_SUCCESS;
+ 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 = JBIC_OUT_OF_MEMORY;
+ else
+ jbi_dr_postamble = count;
+
+ } else
+ jbi_dr_postamble = count;
+
+ if (status == JBIC_SUCCESS) {
+ 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;
+}
+
+JBI_RETURN_TYPE jbi_set_ir_postamble(u32 count, u32 start_index,
+ u8 *postamble_data)
+{
+ JBI_RETURN_TYPE status = JBIC_SUCCESS;
+ 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 = JBIC_OUT_OF_MEMORY;
+ else
+ jbi_ir_postamble = count;
+
+ } else
+ jbi_ir_postamble = count;
+
+ if (status != JBIC_SUCCESS)
+ 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;
+}
+
+JBI_RETURN_TYPE jbi_goto_jtag_state(struct altera_config *astate,
+ enum JBIE_JTAG_STATE state)
+{
+ int tms;
+ int count = 0;
+ JBI_RETURN_TYPE status = JBIC_SUCCESS;
+
+ 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 = JBIC_INTERNAL_ERROR;
+
+ return status;
+}
+
+JBI_RETURN_TYPE jbi_do_wait_cycles(struct altera_config *astate,
+ s32 cycles,
+ enum JBIE_JTAG_STATE wait_state)
+{
+ int tms;
+ s32 count;
+ JBI_RETURN_TYPE status = JBIC_SUCCESS;
+
+ if (jbi_jtag_state != wait_state)
+ status = jbi_goto_jtag_state(astate, wait_state);
+
+ if (status == JBIC_SUCCESS) {
+ /*
+ 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;
+}
+
+JBI_RETURN_TYPE 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 JBIC_SUCCESS for success, else appropriate error code. */
+{
+ JBI_RETURN_TYPE status = JBIC_SUCCESS;
+
+ if ((jbi_jtag_state != JBI_ILLEGAL_JTAG_STATE) &&
+ (jbi_jtag_state != wait_state))
+ status = jbi_goto_jtag_state(astate, wait_state);
+
+ if (status == JBIC_SUCCESS)
+ /* 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));
+
+ }
+}
+
+JBI_RETURN_TYPE 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;
+ JBI_RETURN_TYPE status = JBIC_SUCCESS;
+ 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 = JBIC_INTERNAL_ERROR;
+ break;
+ }
+
+ if (status == JBIC_SUCCESS)
+ if (jbi_jtag_state != start_state)
+ status = jbi_goto_jtag_state(astate, start_state);
+
+ if (status == JBIC_SUCCESS) {
+ 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 = JBIC_OUT_OF_MEMORY;
+ else
+ jbi_ir_length = alloc_chars * 8;
+
+ }
+ }
+
+ if (status == JBIC_SUCCESS) {
+ /* 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 == JBIC_SUCCESS)
+ if (jbi_irstop_state != IRPAUSE)
+ status = jbi_goto_jtag_state(astate, jbi_irstop_state);
+
+
+ return status;
+}
+
+JBI_RETURN_TYPE 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;
+ JBI_RETURN_TYPE status = JBIC_SUCCESS;
+ 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 = JBIC_INTERNAL_ERROR;
+ break;
+ }
+
+ if (status == JBIC_SUCCESS)
+ if (jbi_jtag_state != start_state)
+ status = jbi_goto_jtag_state(astate, start_state);
+
+ if (status == JBIC_SUCCESS) {
+ 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 = JBIC_OUT_OF_MEMORY;
+ else
+ jbi_ir_length = alloc_chars * 8;
+
+ }
+ }
+
+ if (status == JBIC_SUCCESS) {
+ /*
+ 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 == JBIC_SUCCESS)
+ if (jbi_irstop_state != IRPAUSE)
+ status = jbi_goto_jtag_state(astate, jbi_irstop_state);
+
+
+ if (status == JBIC_SUCCESS)
+ /* 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;
+}
+
+JBI_RETURN_TYPE 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;
+ JBI_RETURN_TYPE status = JBIC_SUCCESS;
+ 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 = JBIC_INTERNAL_ERROR;
+ break;
+ }
+
+ if (status == JBIC_SUCCESS)
+ if (jbi_jtag_state != start_state)
+ status = jbi_goto_jtag_state(astate, start_state);
+
+ if (status == JBIC_SUCCESS) {
+ 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 = JBIC_OUT_OF_MEMORY;
+ else
+ jbi_dr_length = alloc_chars * 8;
+
+ }
+ }
+
+ if (status == JBIC_SUCCESS) {
+ /*
+ 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 == JBIC_SUCCESS)
+ if (jbi_drstop_state != DRPAUSE)
+ status = jbi_goto_jtag_state(astate, jbi_drstop_state);
+
+ return status;
+}
+
+JBI_RETURN_TYPE 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;
+ JBI_RETURN_TYPE status = JBIC_SUCCESS;
+ 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 = JBIC_INTERNAL_ERROR;
+ break;
+ }
+
+ if (status == JBIC_SUCCESS)
+ if (jbi_jtag_state != start_state)
+ status = jbi_goto_jtag_state(astate, start_state);
+
+ if (status == JBIC_SUCCESS) {
+ 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 = JBIC_OUT_OF_MEMORY;
+ else
+ jbi_dr_length = alloc_chars * 8;
+
+ }
+ }
+
+ if (status == JBIC_SUCCESS) {
+ /* 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 == JBIC_SUCCESS)
+ if (jbi_drstop_state != DRPAUSE)
+ status = jbi_goto_jtag_state(astate, jbi_drstop_state);
+
+ if (status == JBIC_SUCCESS)
+ /* 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;
+ }
+}
diff --git a/drivers/misc/stapl-altera/jbijtag.h b/drivers/misc/stapl-altera/jbijtag.h
new file mode 100644
index 0000000..d31f302
--- /dev/null
+++ b/drivers/misc/stapl-altera/jbijtag.h
@@ -0,0 +1,83 @@
+/*
+ * jbijtag.h
+ *
+ * altera FPGA driver
+ *
+ * Copyright (C) Altera Corporation 1998-2001
+ * Copyright (C) 2010 NetUP Inc.
+ * Copyright (C) 2010 Igor M. Liplianin <liplianin@xxxxxxxx>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ *
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#ifndef INC_JBIJTAG_H
+#define INC_JBIJTAG_H
+
+/* Function Prototypes */
+enum JBIE_JTAG_STATE {
+ JBI_ILLEGAL_JTAG_STATE = -1,
+ RESET = 0,
+ IDLE = 1,
+ DRSELECT = 2,
+ DRCAPTURE = 3,
+ DRSHIFT = 4,
+ DREXIT1 = 5,
+ DRPAUSE = 6,
+ DREXIT2 = 7,
+ DRUPDATE = 8,
+ IRSELECT = 9,
+ IRCAPTURE = 10,
+ IRSHIFT = 11,
+ IREXIT1 = 12,
+ IRPAUSE = 13,
+ IREXIT2 = 14,
+ IRUPDATE = 15
+
+};
+
+
+JBI_RETURN_TYPE jbi_init_jtag(void);
+JBI_RETURN_TYPE jbi_set_drstop_state(enum JBIE_JTAG_STATE state);
+JBI_RETURN_TYPE jbi_set_irstop_state(enum JBIE_JTAG_STATE state);
+JBI_RETURN_TYPE jbi_set_dr_preamble(u32 count, u32 start_index,
+ u8 *preamble_data);
+JBI_RETURN_TYPE jbi_set_ir_preamble(u32 count, u32 start_index,
+ u8 *preamble_data);
+JBI_RETURN_TYPE jbi_set_dr_postamble(u32 count, u32 start_index,
+ u8 *postamble_data);
+JBI_RETURN_TYPE jbi_set_ir_postamble(u32 count, u32 start_index,
+ u8 *postamble_data);
+JBI_RETURN_TYPE jbi_goto_jtag_state(struct altera_config *astate,
+ enum JBIE_JTAG_STATE state);
+JBI_RETURN_TYPE jbi_do_wait_cycles(struct altera_config *astate,
+ s32 cycles, enum JBIE_JTAG_STATE wait_state);
+JBI_RETURN_TYPE jbi_do_wait_microseconds(struct altera_config *astate,
+ s32 microseconds,
+ enum JBIE_JTAG_STATE wait_state);
+JBI_RETURN_TYPE jbi_do_irscan(struct altera_config *astate, u32 count,
+ u8 *tdi_data, u32 start_index);
+JBI_RETURN_TYPE jbi_swap_ir(struct altera_config *astate,
+ u32 count, u8 *in_data,
+ u32 in_index, u8 *out_data,
+ u32 out_index);
+JBI_RETURN_TYPE jbi_do_drscan(struct altera_config *astate, u32 count,
+ u8 *tdi_data, u32 start_index);
+JBI_RETURN_TYPE jbi_swap_dr(struct altera_config *astate, u32 count,
+ u8 *in_data, u32 in_index,
+ u8 *out_data, u32 out_index);
+void jbi_free_jtag_padding_buffers(struct altera_config *astate/*,
+ int reset_jtag*/);
+#endif /* INC_JBIJTAG_H */
diff --git a/drivers/misc/stapl-altera/jbistub.c b/drivers/misc/stapl-altera/jbistub.c
new file mode 100644
index 0000000..9194afe
--- /dev/null
+++ b/drivers/misc/stapl-altera/jbistub.c
@@ -0,0 +1,70 @@
+/*
+ * jbistub.c
+ *
+ * altera FPGA driver
+ *
+ * Copyright (C) Altera Corporation 1998-2001
+ * Copyright (C) 2010 NetUP Inc.
+ * Copyright (C) 2010 Abylay Ospan <aospan@xxxxxxxx>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ *
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include <linux/io.h>
+#include <linux/kernel.h>
+#include "jbiexprt.h"
+
+int jtag_hardware_initialized;
+
+static void write_byteblaster(int port, int data)
+{
+ outb((u8)data, (u16)(port + 0x378));
+};
+
+static int read_byteblaster(int port)
+{
+ int data = 0;
+ data = inb((u16)(port + 0x378));
+ return data & 0xff;
+};
+
+int netup_jtag_io_lpt(void *device, int tms, int tdi, int read_tdo)
+{
+ int data = 0;
+ int tdo = 0;
+ int initial_lpt_ctrl = 0;
+
+ if (!jtag_hardware_initialized) {
+ initial_lpt_ctrl = read_byteblaster(2);
+ write_byteblaster(2, (initial_lpt_ctrl | 0x02) & 0xdf);
+ jtag_hardware_initialized = 1;
+ }
+
+ data = ((tdi ? 0x40 : 0) | (tms ? 0x02 : 0));
+
+ write_byteblaster(0, data);
+
+ if (read_tdo) {
+ tdo = read_byteblaster(1);
+ tdo = ((tdo & 0x80) ? 0 : 1);
+ }
+
+ write_byteblaster(0, data | 0x01);
+
+ write_byteblaster(0, data);
+
+ return tdo;
+}
diff --git a/include/misc/altera.h b/include/misc/altera.h
new file mode 100644
index 0000000..bf6d878
--- /dev/null
+++ b/include/misc/altera.h
@@ -0,0 +1,49 @@
+/*
+ * altera.h
+ *
+ * altera FPGA driver
+ *
+ * Copyright (C) Altera Corporation 1998-2001
+ * Copyright (C) 2010 NetUP Inc.
+ * Copyright (C) 2010 Igor M. Liplianin <liplianin@xxxxxxxx>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ *
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#ifndef __ALTERA_H
+#define __ALTERA_H
+
+struct altera_config {
+ void *dev;
+ u8 *action;
+ int (*jtag_io) (void *dev, int tms, int tdi, int tdo);
+};
+
+#if defined(CONFIG_STAPL_ALTERA) || \
+ (defined(CONFIG_STAPL_ALTERA_MODULE) && defined(MODULE))
+
+extern int altera_init(struct altera_config *config, const struct firmware *fw);
+#else
+
+static inline int altera_init(struct altera_config *config,
+ const struct firmware *fw)
+{
+ printk(KERN_WARNING "%s: driver disabled by Kconfig\n", __func__);
+ return 0;
+}
+#endif /* CONFIG_STAPL_ALTERA */
+
+#endif /* __ALTERA_H */
--
1.7.1

--
To unsubscribe from this list: send the line "unsubscribe linux-kernel" in
the body of a message to majordomo@xxxxxxxxxxxxxxx
More majordomo info at http://vger.kernel.org/majordomo-info.html
Please read the FAQ at http://www.tux.org/lkml/

Next message: Takashi Iwai: "[PATCH] input: Add multi-touch protocol support to Synaptics"
Messages sorted by: [ date ] [ thread ] [ subject ] [ author ]