8d73a86427360a645132120b621f66b5d3287e29
[linux-3.10.git] / drivers / staging / altera-stapl / altera.c
1 /*
2  * altera.c
3  *
4  * altera FPGA driver
5  *
6  * Copyright (C) Altera Corporation 1998-2001
7  * Copyright (C) 2010,2011 NetUP Inc.
8  * Copyright (C) 2010,2011 Igor M. Liplianin <liplianin@netup.ru>
9  *
10  * This program is free software; you can redistribute it and/or modify
11  * it under the terms of the GNU General Public License as published by
12  * the Free Software Foundation; either version 2 of the License, or
13  * (at your option) any later version.
14  *
15  * This program is distributed in the hope that it will be useful,
16  * but WITHOUT ANY WARRANTY; without even the implied warranty of
17  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
18  *
19  * GNU General Public License for more details.
20  *
21  * You should have received a copy of the GNU General Public License
22  * along with this program; if not, write to the Free Software
23  * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
24  */
25
26 #include <asm/unaligned.h>
27 #include <linux/ctype.h>
28 #include <linux/string.h>
29 #include <linux/firmware.h>
30 #include <linux/slab.h>
31 #include "altera.h"
32 #include "altera-exprt.h"
33 #include "altera-jtag.h"
34
35 static int debug = 1;
36 module_param(debug, int, 0644);
37 MODULE_PARM_DESC(debug, "enable debugging information");
38
39 MODULE_DESCRIPTION("altera FPGA kernel module");
40 MODULE_AUTHOR("Igor M. Liplianin  <liplianin@netup.ru>");
41 MODULE_LICENSE("GPL");
42
43 #define dprintk(args...) \
44         if (debug) { \
45                 printk(KERN_DEBUG args); \
46         }
47
48 enum altera_fpga_opcode {
49         OP_NOP = 0,
50         OP_DUP,
51         OP_SWP,
52         OP_ADD,
53         OP_SUB,
54         OP_MULT,
55         OP_DIV,
56         OP_MOD,
57         OP_SHL,
58         OP_SHR,
59         OP_NOT,
60         OP_AND,
61         OP_OR,
62         OP_XOR,
63         OP_INV,
64         OP_GT,
65         OP_LT,
66         OP_RET,
67         OP_CMPS,
68         OP_PINT,
69         OP_PRNT,
70         OP_DSS,
71         OP_DSSC,
72         OP_ISS,
73         OP_ISSC,
74         OP_DPR = 0x1c,
75         OP_DPRL,
76         OP_DPO,
77         OP_DPOL,
78         OP_IPR,
79         OP_IPRL,
80         OP_IPO,
81         OP_IPOL,
82         OP_PCHR,
83         OP_EXIT,
84         OP_EQU,
85         OP_POPT,
86         OP_ABS = 0x2c,
87         OP_BCH0,
88         OP_PSH0 = 0x2f,
89         OP_PSHL = 0x40,
90         OP_PSHV,
91         OP_JMP,
92         OP_CALL,
93         OP_NEXT,
94         OP_PSTR,
95         OP_SINT = 0x47,
96         OP_ST,
97         OP_ISTP,
98         OP_DSTP,
99         OP_SWPN,
100         OP_DUPN,
101         OP_POPV,
102         OP_POPE,
103         OP_POPA,
104         OP_JMPZ,
105         OP_DS,
106         OP_IS,
107         OP_DPRA,
108         OP_DPOA,
109         OP_IPRA,
110         OP_IPOA,
111         OP_EXPT,
112         OP_PSHE,
113         OP_PSHA,
114         OP_DYNA,
115         OP_EXPV = 0x5c,
116         OP_COPY = 0x80,
117         OP_REVA,
118         OP_DSC,
119         OP_ISC,
120         OP_WAIT,
121         OP_VS,
122         OP_CMPA = 0xc0,
123         OP_VSC,
124 };
125
126 struct altera_procinfo {
127         char                    *name;
128         u8                      attrs;
129         struct altera_procinfo  *next;
130 };
131
132 /* This function checks if enough parameters are available on the stack. */
133 static int altera_check_stack(int stack_ptr, int count, int *status)
134 {
135         if (stack_ptr < count) {
136                 *status = -EOVERFLOW;
137                 return 0;
138         }
139
140         return 1;
141 }
142
143 static void altera_export_int(char *key, s32 value)
144 {
145         dprintk("Export: key = \"%s\", value = %d\n", key, value);
146 }
147
148 #define HEX_LINE_CHARS 72
149 #define HEX_LINE_BITS (HEX_LINE_CHARS * 4)
150
151 static void altera_export_bool_array(char *key, u8 *data, s32 count)
152 {
153         char string[HEX_LINE_CHARS + 1];
154         s32 i, offset;
155         u32 size, line, lines, linebits, value, j, k;
156
157         if (count > HEX_LINE_BITS) {
158                 dprintk("Export: key = \"%s\", %d bits, value = HEX\n",
159                                                         key, count);
160                 lines = (count + (HEX_LINE_BITS - 1)) / HEX_LINE_BITS;
161
162                 for (line = 0; line < lines; ++line) {
163                         if (line < (lines - 1)) {
164                                 linebits = HEX_LINE_BITS;
165                                 size = HEX_LINE_CHARS;
166                                 offset = count - ((line + 1) * HEX_LINE_BITS);
167                         } else {
168                                 linebits =
169                                         count - ((lines - 1) * HEX_LINE_BITS);
170                                 size = (linebits + 3) / 4;
171                                 offset = 0L;
172                         }
173
174                         string[size] = '\0';
175                         j = size - 1;
176                         value = 0;
177
178                         for (k = 0; k < linebits; ++k) {
179                                 i = k + offset;
180                                 if (data[i >> 3] & (1 << (i & 7)))
181                                         value |= (1 << (i & 3));
182                                 if ((i & 3) == 3) {
183                                         sprintf(&string[j], "%1x", value);
184                                         value = 0;
185                                         --j;
186                                 }
187                         }
188                         if ((k & 3) > 0)
189                                 sprintf(&string[j], "%1x", value);
190
191                         dprintk("%s\n", string);
192                 }
193
194         } else {
195                 size = (count + 3) / 4;
196                 string[size] = '\0';
197                 j = size - 1;
198                 value = 0;
199
200                 for (i = 0; i < count; ++i) {
201                         if (data[i >> 3] & (1 << (i & 7)))
202                                 value |= (1 << (i & 3));
203                         if ((i & 3) == 3) {
204                                 sprintf(&string[j], "%1x", value);
205                                 value = 0;
206                                 --j;
207                         }
208                 }
209                 if ((i & 3) > 0)
210                         sprintf(&string[j], "%1x", value);
211
212                 dprintk("Export: key = \"%s\", %d bits, value = HEX %s\n",
213                         key, count, string);
214         }
215 }
216
217 static int altera_execute(struct altera_state *astate,
218                                 u8 *p,
219                                 s32 program_size,
220                                 s32 *error_address,
221                                 int *exit_code,
222                                 int *format_version)
223 {
224         struct altera_config *aconf = astate->config;
225         char *msg_buff = astate->msg_buff;
226         long *stack = astate->stack;
227         int status = 0;
228         u32 first_word = 0L;
229         u32 action_table = 0L;
230         u32 proc_table = 0L;
231         u32 str_table = 0L;
232         u32 sym_table = 0L;
233         u32 data_sect = 0L;
234         u32 code_sect = 0L;
235         u32 debug_sect = 0L;
236         u32 action_count = 0L;
237         u32 proc_count = 0L;
238         u32 sym_count = 0L;
239         long *vars = NULL;
240         s32 *var_size = NULL;
241         char *attrs = NULL;
242         u8 *proc_attributes = NULL;
243         u32 pc;
244         u32 opcode_address;
245         u32 args[3];
246         u32 opcode;
247         u32 name_id;
248         u8 charbuf[4];
249         long long_tmp;
250         u32 variable_id;
251         u8 *charptr_tmp;
252         u8 *charptr_tmp2;
253         long *longptr_tmp;
254         int version = 0;
255         int delta = 0;
256         int stack_ptr = 0;
257         u32 arg_count;
258         int done = 0;
259         int bad_opcode = 0;
260         u32 count;
261         u32 index;
262         u32 index2;
263         s32 long_count;
264         s32 long_idx;
265         s32 long_idx2;
266         u32 i;
267         u32 j;
268         u32 uncomp_size;
269         u32 offset;
270         u32 value;
271         int current_proc = 0;
272         int reverse;
273
274         char *name;
275
276         dprintk("%s\n", __func__);
277
278         /* Read header information */
279         if (program_size > 52L) {
280                 first_word    = get_unaligned_be32(&p[0]);
281                 version = (first_word & 1L);
282                 *format_version = version + 1;
283                 delta = version * 8;
284
285                 action_table  = get_unaligned_be32(&p[4]);
286                 proc_table    = get_unaligned_be32(&p[8]);
287                 str_table  = get_unaligned_be32(&p[4 + delta]);
288                 sym_table  = get_unaligned_be32(&p[16 + delta]);
289                 data_sect  = get_unaligned_be32(&p[20 + delta]);
290                 code_sect  = get_unaligned_be32(&p[24 + delta]);
291                 debug_sect = get_unaligned_be32(&p[28 + delta]);
292                 action_count  = get_unaligned_be32(&p[40 + delta]);
293                 proc_count    = get_unaligned_be32(&p[44 + delta]);
294                 sym_count  = get_unaligned_be32(&p[48 + (2 * delta)]);
295         }
296
297         if ((first_word != 0x4A414D00L) && (first_word != 0x4A414D01L)) {
298                 done = 1;
299                 status = -EIO;
300                 goto exit_done;
301         }
302
303         if (sym_count <= 0)
304                 goto exit_done;
305
306         vars = kzalloc(sym_count * sizeof(long), GFP_KERNEL);
307
308         if (vars == NULL)
309                 status = -ENOMEM;
310
311         if (status == 0) {
312                 var_size = kzalloc(sym_count * sizeof(s32), GFP_KERNEL);
313
314                 if (var_size == NULL)
315                         status = -ENOMEM;
316         }
317
318         if (status == 0) {
319                 attrs = kzalloc(sym_count, GFP_KERNEL);
320
321                 if (attrs == NULL)
322                         status = -ENOMEM;
323         }
324
325         if ((status == 0) && (version > 0)) {
326                 proc_attributes = kzalloc(proc_count, GFP_KERNEL);
327
328                 if (proc_attributes == NULL)
329                         status = -ENOMEM;
330         }
331
332         if (status != 0)
333                 goto exit_done;
334
335         delta = version * 2;
336
337         for (i = 0; i < sym_count; ++i) {
338                 offset = (sym_table + ((11 + delta) * i));
339
340                 value = get_unaligned_be32(&p[offset + 3 + delta]);
341
342                 attrs[i] = p[offset];
343
344                 /*
345                  * use bit 7 of attribute byte to indicate that
346                  * this buffer was dynamically allocated
347                  * and should be freed later
348                  */
349                 attrs[i] &= 0x7f;
350
351                 var_size[i] = get_unaligned_be32(&p[offset + 7 + delta]);
352
353                 /*
354                  * Attribute bits:
355                  * bit 0: 0 = read-only, 1 = read-write
356                  * bit 1: 0 = not compressed, 1 = compressed
357                  * bit 2: 0 = not initialized, 1 = initialized
358                  * bit 3: 0 = scalar, 1 = array
359                  * bit 4: 0 = Boolean, 1 = integer
360                  * bit 5: 0 = declared variable,
361                  *      1 = compiler created temporary variable
362                  */
363
364                 if ((attrs[i] & 0x0c) == 0x04)
365                         /* initialized scalar variable */
366                         vars[i] = value;
367                 else if ((attrs[i] & 0x1e) == 0x0e) {
368                         /* initialized compressed Boolean array */
369                         uncomp_size = get_unaligned_le32(&p[data_sect + value]);
370
371                         /* allocate a buffer for the uncompressed data */
372                         vars[i] = (long)kzalloc(uncomp_size, GFP_KERNEL);
373                         if (vars[i] == 0L)
374                                 status = -ENOMEM;
375                         else {
376                                 /* set flag so buffer will be freed later */
377                                 attrs[i] |= 0x80;
378
379                                 /* uncompress the data */
380                                 if (altera_shrink(&p[data_sect + value],
381                                                 var_size[i],
382                                                 (u8 *)vars[i],
383                                                 uncomp_size,
384                                                 version) != uncomp_size)
385                                         /* decompression failed */
386                                         status = -EIO;
387                                 else
388                                         var_size[i] = uncomp_size * 8L;
389
390                         }
391                 } else if ((attrs[i] & 0x1e) == 0x0c) {
392                         /* initialized Boolean array */
393                         vars[i] = value + data_sect + (long)p;
394                 } else if ((attrs[i] & 0x1c) == 0x1c) {
395                         /* initialized integer array */
396                         vars[i] = value + data_sect;
397                 } else if ((attrs[i] & 0x0c) == 0x08) {
398                         /* uninitialized array */
399
400                         /* flag attrs so that memory is freed */
401                         attrs[i] |= 0x80;
402
403                         if (var_size[i] > 0) {
404                                 u32 size;
405
406                                 if (attrs[i] & 0x10)
407                                         /* integer array */
408                                         size = (var_size[i] * sizeof(s32));
409                                 else
410                                         /* Boolean array */
411                                         size = ((var_size[i] + 7L) / 8L);
412
413                                 vars[i] = (long)kzalloc(size, GFP_KERNEL);
414
415                                 if (vars[i] == 0) {
416                                         status = -ENOMEM;
417                                 } else {
418                                         /* zero out memory */
419                                         for (j = 0; j < size; ++j)
420                                                 ((u8 *)(vars[i]))[j] = 0;
421
422                                 }
423                         } else
424                                 vars[i] = 0;
425
426                 } else
427                         vars[i] = 0;
428
429         }
430
431 exit_done:
432         if (status != 0)
433                 done = 1;
434
435         altera_jinit(astate);
436
437         pc = code_sect;
438         msg_buff[0] = '\0';
439
440         /*
441          * For JBC version 2, we will execute the procedures corresponding to
442          * the selected ACTION
443          */
444         if (version > 0) {
445                 if (aconf->action == NULL) {
446                         status = -EINVAL;
447                         done = 1;
448                 } else {
449                         int action_found = 0;
450                         for (i = 0; (i < action_count) && !action_found; ++i) {
451                                 name_id = get_unaligned_be32(&p[action_table +
452                                                                 (12 * i)]);
453
454                                 name = &p[str_table + name_id];
455
456                                 if (strnicmp(aconf->action, name, strlen(name)) == 0) {
457                                         action_found = 1;
458                                         current_proc =
459                                                 get_unaligned_be32(&p[action_table +
460                                                                 (12 * i) + 8]);
461                                 }
462                         }
463
464                         if (!action_found) {
465                                 status = -EINVAL;
466                                 done = 1;
467                         }
468                 }
469
470                 if (status == 0) {
471                         int first_time = 1;
472                         i = current_proc;
473                         while ((i != 0) || first_time) {
474                                 first_time = 0;
475                                 /* check procedure attribute byte */
476                                 proc_attributes[i] =
477                                                 (p[proc_table +
478                                                                 (13 * i) + 8] &
479                                                                         0x03);
480
481                                 /*
482                                  * BIT0 - OPTIONAL
483                                  * BIT1 - RECOMMENDED
484                                  * BIT6 - FORCED OFF
485                                  * BIT7 - FORCED ON
486                                  */
487
488                                 i = get_unaligned_be32(&p[proc_table +
489                                                         (13 * i) + 4]);
490                         }
491
492                         /*
493                          * Set current_proc to the first procedure
494                          * to be executed
495                          */
496                         i = current_proc;
497                         while ((i != 0) &&
498                                 ((proc_attributes[i] == 1) ||
499                                 ((proc_attributes[i] & 0xc0) == 0x40))) {
500                                 i = get_unaligned_be32(&p[proc_table +
501                                                         (13 * i) + 4]);
502                         }
503
504                         if ((i != 0) || ((i == 0) && (current_proc == 0) &&
505                                 ((proc_attributes[0] != 1) &&
506                                 ((proc_attributes[0] & 0xc0) != 0x40)))) {
507                                 current_proc = i;
508                                 pc = code_sect +
509                                         get_unaligned_be32(&p[proc_table +
510                                                                 (13 * i) + 9]);
511                                 if ((pc < code_sect) || (pc >= debug_sect))
512                                         status = -ERANGE;
513                         } else
514                                 /* there are no procedures to execute! */
515                                 done = 1;
516
517                 }
518         }
519
520         msg_buff[0] = '\0';
521
522         while (!done) {
523                 opcode = (p[pc] & 0xff);
524                 opcode_address = pc;
525                 ++pc;
526
527                 if (debug > 1)
528                         printk("opcode: %02x\n", opcode);
529
530                 arg_count = (opcode >> 6) & 3;
531                 for (i = 0; i < arg_count; ++i) {
532                         args[i] = get_unaligned_be32(&p[pc]);
533                         pc += 4;
534                 }
535
536                 switch (opcode) {
537                 case OP_NOP:
538                         break;
539                 case OP_DUP:
540                         if (altera_check_stack(stack_ptr, 1, &status)) {
541                                 stack[stack_ptr] = stack[stack_ptr - 1];
542                                 ++stack_ptr;
543                         }
544                         break;
545                 case OP_SWP:
546                         if (altera_check_stack(stack_ptr, 2, &status)) {
547                                 long_tmp = stack[stack_ptr - 2];
548                                 stack[stack_ptr - 2] = stack[stack_ptr - 1];
549                                 stack[stack_ptr - 1] = long_tmp;
550                         }
551                         break;
552                 case OP_ADD:
553                         if (altera_check_stack(stack_ptr, 2, &status)) {
554                                 --stack_ptr;
555                                 stack[stack_ptr - 1] += stack[stack_ptr];
556                         }
557                         break;
558                 case OP_SUB:
559                         if (altera_check_stack(stack_ptr, 2, &status)) {
560                                 --stack_ptr;
561                                 stack[stack_ptr - 1] -= stack[stack_ptr];
562                         }
563                         break;
564                 case OP_MULT:
565                         if (altera_check_stack(stack_ptr, 2, &status)) {
566                                 --stack_ptr;
567                                 stack[stack_ptr - 1] *= stack[stack_ptr];
568                         }
569                         break;
570                 case OP_DIV:
571                         if (altera_check_stack(stack_ptr, 2, &status)) {
572                                 --stack_ptr;
573                                 stack[stack_ptr - 1] /= stack[stack_ptr];
574                         }
575                         break;
576                 case OP_MOD:
577                         if (altera_check_stack(stack_ptr, 2, &status)) {
578                                 --stack_ptr;
579                                 stack[stack_ptr - 1] %= stack[stack_ptr];
580                         }
581                         break;
582                 case OP_SHL:
583                         if (altera_check_stack(stack_ptr, 2, &status)) {
584                                 --stack_ptr;
585                                 stack[stack_ptr - 1] <<= stack[stack_ptr];
586                         }
587                         break;
588                 case OP_SHR:
589                         if (altera_check_stack(stack_ptr, 2, &status)) {
590                                 --stack_ptr;
591                                 stack[stack_ptr - 1] >>= stack[stack_ptr];
592                         }
593                         break;
594                 case OP_NOT:
595                         if (altera_check_stack(stack_ptr, 1, &status))
596                                 stack[stack_ptr - 1] ^= (-1L);
597
598                         break;
599                 case OP_AND:
600                         if (altera_check_stack(stack_ptr, 2, &status)) {
601                                 --stack_ptr;
602                                 stack[stack_ptr - 1] &= stack[stack_ptr];
603                         }
604                         break;
605                 case OP_OR:
606                         if (altera_check_stack(stack_ptr, 2, &status)) {
607                                 --stack_ptr;
608                                 stack[stack_ptr - 1] |= stack[stack_ptr];
609                         }
610                         break;
611                 case OP_XOR:
612                         if (altera_check_stack(stack_ptr, 2, &status)) {
613                                 --stack_ptr;
614                                 stack[stack_ptr - 1] ^= stack[stack_ptr];
615                         }
616                         break;
617                 case OP_INV:
618                         if (!altera_check_stack(stack_ptr, 1, &status))
619                                 break;
620                         stack[stack_ptr - 1] = stack[stack_ptr - 1] ? 0L : 1L;
621                         break;
622                 case OP_GT:
623                         if (!altera_check_stack(stack_ptr, 2, &status))
624                                 break;
625                         --stack_ptr;
626                         stack[stack_ptr - 1] =
627                                 (stack[stack_ptr - 1] > stack[stack_ptr]) ?
628                                                                         1L : 0L;
629
630                         break;
631                 case OP_LT:
632                         if (!altera_check_stack(stack_ptr, 2, &status))
633                                 break;
634                         --stack_ptr;
635                         stack[stack_ptr - 1] =
636                                 (stack[stack_ptr - 1] < stack[stack_ptr]) ?
637                                                                         1L : 0L;
638
639                         break;
640                 case OP_RET:
641                         if ((version > 0) && (stack_ptr == 0)) {
642                                 /*
643                                  * We completed one of the main procedures
644                                  * of an ACTION.
645                                  * Find the next procedure
646                                  * to be executed and jump to it.
647                                  * If there are no more procedures, then EXIT.
648                                  */
649                                 i = get_unaligned_be32(&p[proc_table +
650                                                 (13 * current_proc) + 4]);
651                                 while ((i != 0) &&
652                                         ((proc_attributes[i] == 1) ||
653                                         ((proc_attributes[i] & 0xc0) == 0x40)))
654                                         i = get_unaligned_be32(&p[proc_table +
655                                                                 (13 * i) + 4]);
656
657                                 if (i == 0) {
658                                         /* no procedures to execute! */
659                                         done = 1;
660                                         *exit_code = 0; /* success */
661                                 } else {
662                                         current_proc = i;
663                                         pc = code_sect + get_unaligned_be32(
664                                                                 &p[proc_table +
665                                                                 (13 * i) + 9]);
666                                         if ((pc < code_sect) ||
667                                             (pc >= debug_sect))
668                                                 status = -ERANGE;
669                                 }
670
671                         } else
672                                 if (altera_check_stack(stack_ptr, 1, &status)) {
673                                         pc = stack[--stack_ptr] + code_sect;
674                                         if ((pc <= code_sect) ||
675                                             (pc >= debug_sect))
676                                                 status = -ERANGE;
677
678                                 }
679
680                         break;
681                 case OP_CMPS:
682                         /*
683                          * Array short compare
684                          * ...stack 0 is source 1 value
685                          * ...stack 1 is source 2 value
686                          * ...stack 2 is mask value
687                          * ...stack 3 is count
688                          */
689                         if (altera_check_stack(stack_ptr, 4, &status)) {
690                                 s32 a = stack[--stack_ptr];
691                                 s32 b = stack[--stack_ptr];
692                                 long_tmp = stack[--stack_ptr];
693                                 count = stack[stack_ptr - 1];
694
695                                 if ((count < 1) || (count > 32))
696                                         status = -ERANGE;
697                                 else {
698                                         long_tmp &= ((-1L) >> (32 - count));
699
700                                         stack[stack_ptr - 1] =
701                                         ((a & long_tmp) == (b & long_tmp))
702                                                                 ? 1L : 0L;
703                                 }
704                         }
705                         break;
706                 case OP_PINT:
707                         /*
708                          * PRINT add integer
709                          * ...stack 0 is integer value
710                          */
711                         if (!altera_check_stack(stack_ptr, 1, &status))
712                                 break;
713                         sprintf(&msg_buff[strlen(msg_buff)],
714                                         "%ld", stack[--stack_ptr]);
715                         break;
716                 case OP_PRNT:
717                         /* PRINT finish */
718                         if (debug)
719                                 printk(msg_buff, "\n");
720
721                         msg_buff[0] = '\0';
722                         break;
723                 case OP_DSS:
724                         /*
725                          * DRSCAN short
726                          * ...stack 0 is scan data
727                          * ...stack 1 is count
728                          */
729                         if (!altera_check_stack(stack_ptr, 2, &status))
730                                 break;
731                         long_tmp = stack[--stack_ptr];
732                         count = stack[--stack_ptr];
733                         put_unaligned_le32(long_tmp, &charbuf[0]);
734                         status = altera_drscan(astate, count, charbuf, 0);
735                         break;
736                 case OP_DSSC:
737                         /*
738                          * DRSCAN short with capture
739                          * ...stack 0 is scan data
740                          * ...stack 1 is count
741                          */
742                         if (!altera_check_stack(stack_ptr, 2, &status))
743                                 break;
744                         long_tmp = stack[--stack_ptr];
745                         count = stack[stack_ptr - 1];
746                         put_unaligned_le32(long_tmp, &charbuf[0]);
747                         status = altera_swap_dr(astate, count, charbuf,
748                                                         0, charbuf, 0);
749                         stack[stack_ptr - 1] = get_unaligned_le32(&charbuf[0]);
750                         break;
751                 case OP_ISS:
752                         /*
753                          * IRSCAN short
754                          * ...stack 0 is scan data
755                          * ...stack 1 is count
756                          */
757                         if (!altera_check_stack(stack_ptr, 2, &status))
758                                 break;
759                         long_tmp = stack[--stack_ptr];
760                         count = stack[--stack_ptr];
761                         put_unaligned_le32(long_tmp, &charbuf[0]);
762                         status = altera_irscan(astate, count, charbuf, 0);
763                         break;
764                 case OP_ISSC:
765                         /*
766                          * IRSCAN short with capture
767                          * ...stack 0 is scan data
768                          * ...stack 1 is count
769                          */
770                         if (!altera_check_stack(stack_ptr, 2, &status))
771                                 break;
772                         long_tmp = stack[--stack_ptr];
773                         count = stack[stack_ptr - 1];
774                         put_unaligned_le32(long_tmp, &charbuf[0]);
775                         status = altera_swap_ir(astate, count, charbuf,
776                                                         0, charbuf, 0);
777                         stack[stack_ptr - 1] = get_unaligned_le32(&charbuf[0]);
778                         break;
779                 case OP_DPR:
780                         if (!altera_check_stack(stack_ptr, 1, &status))
781                                 break;
782                         count = stack[--stack_ptr];
783                         status = altera_set_dr_pre(&astate->js, count, 0, NULL);
784                         break;
785                 case OP_DPRL:
786                         /*
787                          * DRPRE with literal data
788                          * ...stack 0 is count
789                          * ...stack 1 is literal data
790                          */
791                         if (!altera_check_stack(stack_ptr, 2, &status))
792                                 break;
793                         count = stack[--stack_ptr];
794                         long_tmp = stack[--stack_ptr];
795                         put_unaligned_le32(long_tmp, &charbuf[0]);
796                         status = altera_set_dr_pre(&astate->js, count, 0,
797                                                 charbuf);
798                         break;
799                 case OP_DPO:
800                         /*
801                          * DRPOST
802                          * ...stack 0 is count
803                          */
804                         if (altera_check_stack(stack_ptr, 1, &status)) {
805                                 count = stack[--stack_ptr];
806                                 status = altera_set_dr_post(&astate->js, count,
807                                                                 0, NULL);
808                         }
809                         break;
810                 case OP_DPOL:
811                         /*
812                          * DRPOST with literal data
813                          * ...stack 0 is count
814                          * ...stack 1 is literal data
815                          */
816                         if (!altera_check_stack(stack_ptr, 2, &status))
817                                 break;
818                         count = stack[--stack_ptr];
819                         long_tmp = stack[--stack_ptr];
820                         put_unaligned_le32(long_tmp, &charbuf[0]);
821                         status = altera_set_dr_post(&astate->js, count, 0,
822                                                         charbuf);
823                         break;
824                 case OP_IPR:
825                         if (altera_check_stack(stack_ptr, 1, &status)) {
826                                 count = stack[--stack_ptr];
827                                 status = altera_set_ir_pre(&astate->js, count,
828                                                                 0, NULL);
829                         }
830                         break;
831                 case OP_IPRL:
832                         /*
833                          * IRPRE with literal data
834                          * ...stack 0 is count
835                          * ...stack 1 is literal data
836                          */
837                         if (altera_check_stack(stack_ptr, 2, &status)) {
838                                 count = stack[--stack_ptr];
839                                 long_tmp = stack[--stack_ptr];
840                                 put_unaligned_le32(long_tmp, &charbuf[0]);
841                                 status = altera_set_ir_pre(&astate->js, count,
842                                                         0, charbuf);
843                         }
844                         break;
845                 case OP_IPO:
846                         /*
847                          * IRPOST
848                          * ...stack 0 is count
849                          */
850                         if (altera_check_stack(stack_ptr, 1, &status)) {
851                                 count = stack[--stack_ptr];
852                                 status = altera_set_ir_post(&astate->js, count,
853                                                         0, NULL);
854                         }
855                         break;
856                 case OP_IPOL:
857                         /*
858                          * IRPOST with literal data
859                          * ...stack 0 is count
860                          * ...stack 1 is literal data
861                          */
862                         if (!altera_check_stack(stack_ptr, 2, &status))
863                                 break;
864                         count = stack[--stack_ptr];
865                         long_tmp = stack[--stack_ptr];
866                         put_unaligned_le32(long_tmp, &charbuf[0]);
867                         status = altera_set_ir_post(&astate->js, count, 0,
868                                                         charbuf);
869                         break;
870                 case OP_PCHR:
871                         if (altera_check_stack(stack_ptr, 1, &status)) {
872                                 u8 ch;
873                                 count = strlen(msg_buff);
874                                 ch = (char) stack[--stack_ptr];
875                                 if ((ch < 1) || (ch > 127)) {
876                                         /*
877                                          * character code out of range
878                                          * instead of flagging an error,
879                                          * force the value to 127
880                                          */
881                                         ch = 127;
882                                 }
883                                 msg_buff[count] = ch;
884                                 msg_buff[count + 1] = '\0';
885                         }
886                         break;
887                 case OP_EXIT:
888                         if (altera_check_stack(stack_ptr, 1, &status))
889                                 *exit_code = stack[--stack_ptr];
890
891                         done = 1;
892                         break;
893                 case OP_EQU:
894                         if (!altera_check_stack(stack_ptr, 2, &status))
895                                 break;
896                         --stack_ptr;
897                         stack[stack_ptr - 1] =
898                                 (stack[stack_ptr - 1] == stack[stack_ptr]) ?
899                                                                         1L : 0L;
900                         break;
901                 case OP_POPT:
902                         if (altera_check_stack(stack_ptr, 1, &status))
903                                 --stack_ptr;
904
905                         break;
906                 case OP_ABS:
907                         if (!altera_check_stack(stack_ptr, 1, &status))
908                                 break;
909                         if (stack[stack_ptr - 1] < 0)
910                                 stack[stack_ptr - 1] = 0 - stack[stack_ptr - 1];
911
912                         break;
913                 case OP_BCH0:
914                         /*
915                          * Batch operation 0
916                          * SWP
917                          * SWPN 7
918                          * SWP
919                          * SWPN 6
920                          * DUPN 8
921                          * SWPN 2
922                          * SWP
923                          * DUPN 6
924                          * DUPN 6
925                          */
926
927                         /* SWP  */
928                         if (altera_check_stack(stack_ptr, 2, &status)) {
929                                 long_tmp = stack[stack_ptr - 2];
930                                 stack[stack_ptr - 2] = stack[stack_ptr - 1];
931                                 stack[stack_ptr - 1] = long_tmp;
932                         }
933
934                         /* SWPN 7 */
935                         index = 7 + 1;
936                         if (altera_check_stack(stack_ptr, index, &status)) {
937                                 long_tmp = stack[stack_ptr - index];
938                                 stack[stack_ptr - index] = stack[stack_ptr - 1];
939                                 stack[stack_ptr - 1] = long_tmp;
940                         }
941
942                         /* SWP  */
943                         if (altera_check_stack(stack_ptr, 2, &status)) {
944                                 long_tmp = stack[stack_ptr - 2];
945                                 stack[stack_ptr - 2] = stack[stack_ptr - 1];
946                                 stack[stack_ptr - 1] = long_tmp;
947                         }
948
949                         /* SWPN 6 */
950                         index = 6 + 1;
951                         if (altera_check_stack(stack_ptr, index, &status)) {
952                                 long_tmp = stack[stack_ptr - index];
953                                 stack[stack_ptr - index] = stack[stack_ptr - 1];
954                                 stack[stack_ptr - 1] = long_tmp;
955                         }
956
957                         /* DUPN 8 */
958                         index = 8 + 1;
959                         if (altera_check_stack(stack_ptr, index, &status)) {
960                                 stack[stack_ptr] = stack[stack_ptr - index];
961                                 ++stack_ptr;
962                         }
963
964                         /* SWPN 2 */
965                         index = 2 + 1;
966                         if (altera_check_stack(stack_ptr, index, &status)) {
967                                 long_tmp = stack[stack_ptr - index];
968                                 stack[stack_ptr - index] = stack[stack_ptr - 1];
969                                 stack[stack_ptr - 1] = long_tmp;
970                         }
971
972                         /* SWP  */
973                         if (altera_check_stack(stack_ptr, 2, &status)) {
974                                 long_tmp = stack[stack_ptr - 2];
975                                 stack[stack_ptr - 2] = stack[stack_ptr - 1];
976                                 stack[stack_ptr - 1] = long_tmp;
977                         }
978
979                         /* DUPN 6 */
980                         index = 6 + 1;
981                         if (altera_check_stack(stack_ptr, index, &status)) {
982                                 stack[stack_ptr] = stack[stack_ptr - index];
983                                 ++stack_ptr;
984                         }
985
986                         /* DUPN 6 */
987                         index = 6 + 1;
988                         if (altera_check_stack(stack_ptr, index, &status)) {
989                                 stack[stack_ptr] = stack[stack_ptr - index];
990                                 ++stack_ptr;
991                         }
992                         break;
993                 case OP_PSH0:
994                         stack[stack_ptr++] = 0;
995                         break;
996                 case OP_PSHL:
997                         stack[stack_ptr++] = (s32) args[0];
998                         break;
999                 case OP_PSHV:
1000                         stack[stack_ptr++] = vars[args[0]];
1001                         break;
1002                 case OP_JMP:
1003                         pc = args[0] + code_sect;
1004                         if ((pc < code_sect) || (pc >= debug_sect))
1005                                 status = -ERANGE;
1006                         break;
1007                 case OP_CALL:
1008                         stack[stack_ptr++] = pc;
1009                         pc = args[0] + code_sect;
1010                         if ((pc < code_sect) || (pc >= debug_sect))
1011                                 status = -ERANGE;
1012                         break;
1013                 case OP_NEXT:
1014                         /*
1015                          * Process FOR / NEXT loop
1016                          * ...argument 0 is variable ID
1017                          * ...stack 0 is step value
1018                          * ...stack 1 is end value
1019                          * ...stack 2 is top address
1020                          */
1021                         if (altera_check_stack(stack_ptr, 3, &status)) {
1022                                 s32 step = stack[stack_ptr - 1];
1023                                 s32 end = stack[stack_ptr - 2];
1024                                 s32 top = stack[stack_ptr - 3];
1025                                 s32 iterator = vars[args[0]];
1026                                 int break_out = 0;
1027
1028                                 if (step < 0) {
1029                                         if (iterator <= end)
1030                                                 break_out = 1;
1031                                 } else if (iterator >= end)
1032                                         break_out = 1;
1033
1034                                 if (break_out) {
1035                                         stack_ptr -= 3;
1036                                 } else {
1037                                         vars[args[0]] = iterator + step;
1038                                         pc = top + code_sect;
1039                                         if ((pc < code_sect) ||
1040                                             (pc >= debug_sect))
1041                                                 status = -ERANGE;
1042                                 }
1043                         }
1044                         break;
1045                 case OP_PSTR:
1046                         /*
1047                          * PRINT add string
1048                          * ...argument 0 is string ID
1049                          */
1050                         count = strlen(msg_buff);
1051                         strlcpy(&msg_buff[count],
1052                                 &p[str_table + args[0]],
1053                                 ALTERA_MESSAGE_LENGTH - count);
1054                         break;
1055                 case OP_SINT:
1056                         /*
1057                          * STATE intermediate state
1058                          * ...argument 0 is state code
1059                          */
1060                         status = altera_goto_jstate(astate, args[0]);
1061                         break;
1062                 case OP_ST:
1063                         /*
1064                          * STATE final state
1065                          * ...argument 0 is state code
1066                          */
1067                         status = altera_goto_jstate(astate, args[0]);
1068                         break;
1069                 case OP_ISTP:
1070                         /*
1071                          * IRSTOP state
1072                          * ...argument 0 is state code
1073                          */
1074                         status = altera_set_irstop(&astate->js, args[0]);
1075                         break;
1076                 case OP_DSTP:
1077                         /*
1078                          * DRSTOP state
1079                          * ...argument 0 is state code
1080                          */
1081                         status = altera_set_drstop(&astate->js, args[0]);
1082                         break;
1083
1084                 case OP_SWPN:
1085                         /*
1086                          * Exchange top with Nth stack value
1087                          * ...argument 0 is 0-based stack entry
1088                          * to swap with top element
1089                          */
1090                         index = (args[0]) + 1;
1091                         if (altera_check_stack(stack_ptr, index, &status)) {
1092                                 long_tmp = stack[stack_ptr - index];
1093                                 stack[stack_ptr - index] = stack[stack_ptr - 1];
1094                                 stack[stack_ptr - 1] = long_tmp;
1095                         }
1096                         break;
1097                 case OP_DUPN:
1098                         /*
1099                          * Duplicate Nth stack value
1100                          * ...argument 0 is 0-based stack entry to duplicate
1101                          */
1102                         index = (args[0]) + 1;
1103                         if (altera_check_stack(stack_ptr, index, &status)) {
1104                                 stack[stack_ptr] = stack[stack_ptr - index];
1105                                 ++stack_ptr;
1106                         }
1107                         break;
1108                 case OP_POPV:
1109                         /*
1110                          * Pop stack into scalar variable
1111                          * ...argument 0 is variable ID
1112                          * ...stack 0 is value
1113                          */
1114                         if (altera_check_stack(stack_ptr, 1, &status))
1115                                 vars[args[0]] = stack[--stack_ptr];
1116
1117                         break;
1118                 case OP_POPE:
1119                         /*
1120                          * Pop stack into integer array element
1121                          * ...argument 0 is variable ID
1122                          * ...stack 0 is array index
1123                          * ...stack 1 is value
1124                          */
1125                         if (!altera_check_stack(stack_ptr, 2, &status))
1126                                 break;
1127                         variable_id = args[0];
1128
1129                         /*
1130                          * If variable is read-only,
1131                          * convert to writable array
1132                          */
1133                         if ((version > 0) &&
1134                                 ((attrs[variable_id] & 0x9c) == 0x1c)) {
1135                                 /* Allocate a writable buffer for this array */
1136                                 count = var_size[variable_id];
1137                                 long_tmp = vars[variable_id];
1138                                 longptr_tmp = kzalloc(count * sizeof(long),
1139                                                                 GFP_KERNEL);
1140                                 vars[variable_id] = (long)longptr_tmp;
1141
1142                                 if (vars[variable_id] == 0) {
1143                                         status = -ENOMEM;
1144                                         break;
1145                                 }
1146
1147                                 /* copy previous contents into buffer */
1148                                 for (i = 0; i < count; ++i) {
1149                                         longptr_tmp[i] =
1150                                                 get_unaligned_be32(&p[long_tmp]);
1151                                         long_tmp += sizeof(long);
1152                                 }
1153
1154                                 /*
1155                                  * set bit 7 - buffer was
1156                                  * dynamically allocated
1157                                  */
1158                                 attrs[variable_id] |= 0x80;
1159
1160                                 /* clear bit 2 - variable is writable */
1161                                 attrs[variable_id] &= ~0x04;
1162                                 attrs[variable_id] |= 0x01;
1163
1164                         }
1165
1166                         /* check that variable is a writable integer array */
1167                         if ((attrs[variable_id] & 0x1c) != 0x18)
1168                                 status = -ERANGE;
1169                         else {
1170                                 longptr_tmp = (long *)vars[variable_id];
1171
1172                                 /* pop the array index */
1173                                 index = stack[--stack_ptr];
1174
1175                                 /* pop the value and store it into the array */
1176                                 longptr_tmp[index] = stack[--stack_ptr];
1177                         }
1178
1179                         break;
1180                 case OP_POPA:
1181                         /*
1182                          * Pop stack into Boolean array
1183                          * ...argument 0 is variable ID
1184                          * ...stack 0 is count
1185                          * ...stack 1 is array index
1186                          * ...stack 2 is value
1187                          */
1188                         if (!altera_check_stack(stack_ptr, 3, &status))
1189                                 break;
1190                         variable_id = args[0];
1191
1192                         /*
1193                          * If variable is read-only,
1194                          * convert to writable array
1195                          */
1196                         if ((version > 0) &&
1197                                 ((attrs[variable_id] & 0x9c) == 0x0c)) {
1198                                 /* Allocate a writable buffer for this array */
1199                                 long_tmp =
1200                                         (var_size[variable_id] + 7L) >> 3L;
1201                                 charptr_tmp2 = (u8 *)vars[variable_id];
1202                                 charptr_tmp =
1203                                         kzalloc(long_tmp, GFP_KERNEL);
1204                                 vars[variable_id] = (long)charptr_tmp;
1205
1206                                 if (vars[variable_id] == 0) {
1207                                         status = -ENOMEM;
1208                                         break;
1209                                 }
1210
1211                                 /* zero the buffer */
1212                                 for (long_idx = 0L;
1213                                         long_idx < long_tmp;
1214                                         ++long_idx) {
1215                                         charptr_tmp[long_idx] = 0;
1216                                 }
1217
1218                                 /* copy previous contents into buffer */
1219                                 for (long_idx = 0L;
1220                                         long_idx < var_size[variable_id];
1221                                         ++long_idx) {
1222                                         long_idx2 = long_idx;
1223
1224                                         if (charptr_tmp2[long_idx2 >> 3] &
1225                                                 (1 << (long_idx2 & 7))) {
1226                                                 charptr_tmp[long_idx >> 3] |=
1227                                                         (1 << (long_idx & 7));
1228                                         }
1229                                 }
1230
1231                                 /*
1232                                  * set bit 7 - buffer was
1233                                  * dynamically allocated
1234                                  */
1235                                 attrs[variable_id] |= 0x80;
1236
1237                                 /* clear bit 2 - variable is writable */
1238                                 attrs[variable_id] &= ~0x04;
1239                                 attrs[variable_id] |= 0x01;
1240
1241                         }
1242
1243                         /*
1244                          * check that variable is
1245                          * a writable Boolean array
1246                          */
1247                         if ((attrs[variable_id] & 0x1c) != 0x08) {
1248                                 status = -ERANGE;
1249                                 break;
1250                         }
1251
1252                         charptr_tmp = (u8 *)vars[variable_id];
1253
1254                         /* pop the count (number of bits to copy) */
1255                         long_count = stack[--stack_ptr];
1256
1257                         /* pop the array index */
1258                         long_idx = stack[--stack_ptr];
1259
1260                         reverse = 0;
1261
1262                         if (version > 0) {
1263                                 /*
1264                                  * stack 0 = array right index
1265                                  * stack 1 = array left index
1266                                  */
1267
1268                                 if (long_idx > long_count) {
1269                                         reverse = 1;
1270                                         long_tmp = long_count;
1271                                         long_count = 1 + long_idx -
1272                                                                 long_count;
1273                                         long_idx = long_tmp;
1274
1275                                         /* reverse POPA is not supported */
1276                                         status = -ERANGE;
1277                                         break;
1278                                 } else
1279                                         long_count = 1 + long_count -
1280                                                                 long_idx;
1281
1282                         }
1283
1284                         /* pop the data */
1285                         long_tmp = stack[--stack_ptr];
1286
1287                         if (long_count < 1) {
1288                                 status = -ERANGE;
1289                                 break;
1290                         }
1291
1292                         for (i = 0; i < long_count; ++i) {
1293                                 if (long_tmp & (1L << (s32) i))
1294                                         charptr_tmp[long_idx >> 3L] |=
1295                                                 (1L << (long_idx & 7L));
1296                                 else
1297                                         charptr_tmp[long_idx >> 3L] &=
1298                                                 ~(1L << (long_idx & 7L));
1299
1300                                 ++long_idx;
1301                         }
1302
1303                         break;
1304                 case OP_JMPZ:
1305                         /*
1306                          * Pop stack and branch if zero
1307                          * ...argument 0 is address
1308                          * ...stack 0 is condition value
1309                          */
1310                         if (altera_check_stack(stack_ptr, 1, &status)) {
1311                                 if (stack[--stack_ptr] == 0) {
1312                                         pc = args[0] + code_sect;
1313                                         if ((pc < code_sect) ||
1314                                             (pc >= debug_sect))
1315                                                 status = -ERANGE;
1316                                 }
1317                         }
1318                         break;
1319                 case OP_DS:
1320                 case OP_IS:
1321                         /*
1322                          * DRSCAN
1323                          * IRSCAN
1324                          * ...argument 0 is scan data variable ID
1325                          * ...stack 0 is array index
1326                          * ...stack 1 is count
1327                          */
1328                         if (!altera_check_stack(stack_ptr, 2, &status))
1329                                 break;
1330                         long_idx = stack[--stack_ptr];
1331                         long_count = stack[--stack_ptr];
1332                         reverse = 0;
1333                         if (version > 0) {
1334                                 /*
1335                                  * stack 0 = array right index
1336                                  * stack 1 = array left index
1337                                  * stack 2 = count
1338                                  */
1339                                 long_tmp = long_count;
1340                                 long_count = stack[--stack_ptr];
1341
1342                                 if (long_idx > long_tmp) {
1343                                         reverse = 1;
1344                                         long_idx = long_tmp;
1345                                 }
1346                         }
1347
1348                         charptr_tmp = (u8 *)vars[args[0]];
1349
1350                         if (reverse) {
1351                                 /*
1352                                  * allocate a buffer
1353                                  * and reverse the data order
1354                                  */
1355                                 charptr_tmp2 = charptr_tmp;
1356                                 charptr_tmp = kzalloc((long_count >> 3) + 1,
1357                                                                 GFP_KERNEL);
1358                                 if (charptr_tmp == NULL) {
1359                                         status = -ENOMEM;
1360                                         break;
1361                                 }
1362
1363                                 long_tmp = long_idx + long_count - 1;
1364                                 long_idx2 = 0;
1365                                 while (long_idx2 < long_count) {
1366                                         if (charptr_tmp2[long_tmp >> 3] &
1367                                                         (1 << (long_tmp & 7)))
1368                                                 charptr_tmp[long_idx2 >> 3] |=
1369                                                         (1 << (long_idx2 & 7));
1370                                         else
1371                                                 charptr_tmp[long_idx2 >> 3] &=
1372                                                         ~(1 << (long_idx2 & 7));
1373
1374                                         --long_tmp;
1375                                         ++long_idx2;
1376                                 }
1377                         }
1378
1379                         if (opcode == 0x51) /* DS */
1380                                 status = altera_drscan(astate, long_count,
1381                                                 charptr_tmp, long_idx);
1382                         else /* IS */
1383                                 status = altera_irscan(astate, long_count,
1384                                                 charptr_tmp, long_idx);
1385
1386                         if (reverse)
1387                                 kfree(charptr_tmp);
1388
1389                         break;
1390                 case OP_DPRA:
1391                         /*
1392                          * DRPRE with array data
1393                          * ...argument 0 is variable ID
1394                          * ...stack 0 is array index
1395                          * ...stack 1 is count
1396                          */
1397                         if (!altera_check_stack(stack_ptr, 2, &status))
1398                                 break;
1399                         index = stack[--stack_ptr];
1400                         count = stack[--stack_ptr];
1401
1402                         if (version > 0)
1403                                 /*
1404                                  * stack 0 = array right index
1405                                  * stack 1 = array left index
1406                                  */
1407                                 count = 1 + count - index;
1408
1409                         charptr_tmp = (u8 *)vars[args[0]];
1410                         status = altera_set_dr_pre(&astate->js, count, index,
1411                                                         charptr_tmp);
1412                         break;
1413                 case OP_DPOA:
1414                         /*
1415                          * DRPOST with array data
1416                          * ...argument 0 is variable ID
1417                          * ...stack 0 is array index
1418                          * ...stack 1 is count
1419                          */
1420                         if (!altera_check_stack(stack_ptr, 2, &status))
1421                                 break;
1422                         index = stack[--stack_ptr];
1423                         count = stack[--stack_ptr];
1424
1425                         if (version > 0)
1426                                 /*
1427                                  * stack 0 = array right index
1428                                  * stack 1 = array left index
1429                                  */
1430                                 count = 1 + count - index;
1431
1432                         charptr_tmp = (u8 *)vars[args[0]];
1433                         status = altera_set_dr_post(&astate->js, count, index,
1434                                                         charptr_tmp);
1435                         break;
1436                 case OP_IPRA:
1437                         /*
1438                          * IRPRE with array data
1439                          * ...argument 0 is variable ID
1440                          * ...stack 0 is array index
1441                          * ...stack 1 is count
1442                          */
1443                         if (!altera_check_stack(stack_ptr, 2, &status))
1444                                 break;
1445                         index = stack[--stack_ptr];
1446                         count = stack[--stack_ptr];
1447
1448                         if (version > 0)
1449                                 /*
1450                                  * stack 0 = array right index
1451                                  * stack 1 = array left index
1452                                  */
1453                                 count = 1 + count - index;
1454
1455                         charptr_tmp = (u8 *)vars[args[0]];
1456                         status = altera_set_ir_pre(&astate->js, count, index,
1457                                                         charptr_tmp);
1458
1459                         break;
1460                 case OP_IPOA:
1461                         /*
1462                          * IRPOST with array data
1463                          * ...argument 0 is variable ID
1464                          * ...stack 0 is array index
1465                          * ...stack 1 is count
1466                          */
1467                         if (!altera_check_stack(stack_ptr, 2, &status))
1468                                 break;
1469                         index = stack[--stack_ptr];
1470                         count = stack[--stack_ptr];
1471
1472                         if (version > 0)
1473                                 /*
1474                                  * stack 0 = array right index
1475                                  * stack 1 = array left index
1476                                  */
1477                                 count = 1 + count - index;
1478
1479                         charptr_tmp = (u8 *)vars[args[0]];
1480                         status = altera_set_ir_post(&astate->js, count, index,
1481                                                         charptr_tmp);
1482
1483                         break;
1484                 case OP_EXPT:
1485                         /*
1486                          * EXPORT
1487                          * ...argument 0 is string ID
1488                          * ...stack 0 is integer expression
1489                          */
1490                         if (altera_check_stack(stack_ptr, 1, &status)) {
1491                                 name = &p[str_table + args[0]];
1492                                 long_tmp = stack[--stack_ptr];
1493                                 altera_export_int(name, long_tmp);
1494                         }
1495                         break;
1496                 case OP_PSHE:
1497                         /*
1498                          * Push integer array element
1499                          * ...argument 0 is variable ID
1500                          * ...stack 0 is array index
1501                          */
1502                         if (!altera_check_stack(stack_ptr, 1, &status))
1503                                 break;
1504                         variable_id = args[0];
1505                         index = stack[stack_ptr - 1];
1506
1507                         /* check variable type */
1508                         if ((attrs[variable_id] & 0x1f) == 0x19) {
1509                                 /* writable integer array */
1510                                 longptr_tmp = (long *)vars[variable_id];
1511                                 stack[stack_ptr - 1] = longptr_tmp[index];
1512                         } else if ((attrs[variable_id] & 0x1f) == 0x1c) {
1513                                 /* read-only integer array */
1514                                 long_tmp = vars[variable_id] +
1515                                                 (index * sizeof(long));
1516                                 stack[stack_ptr - 1] =
1517                                         get_unaligned_be32(&p[long_tmp]);
1518                         } else
1519                                 status = -ERANGE;
1520
1521                         break;
1522                 case OP_PSHA:
1523                         /*
1524                          * Push Boolean array
1525                          * ...argument 0 is variable ID
1526                          * ...stack 0 is count
1527                          * ...stack 1 is array index
1528                          */
1529                         if (!altera_check_stack(stack_ptr, 2, &status))
1530                                 break;
1531                         variable_id = args[0];
1532
1533                         /* check that variable is a Boolean array */
1534                         if ((attrs[variable_id] & 0x18) != 0x08) {
1535                                 status = -ERANGE;
1536                                 break;
1537                         }
1538
1539                         charptr_tmp = (u8 *)vars[variable_id];
1540
1541                         /* pop the count (number of bits to copy) */
1542                         count = stack[--stack_ptr];
1543
1544                         /* pop the array index */
1545                         index = stack[stack_ptr - 1];
1546
1547                         if (version > 0)
1548                                 /*
1549                                  * stack 0 = array right index
1550                                  * stack 1 = array left index
1551                                  */
1552                                 count = 1 + count - index;
1553
1554                         if ((count < 1) || (count > 32)) {
1555                                 status = -ERANGE;
1556                                 break;
1557                         }
1558
1559                         long_tmp = 0L;
1560
1561                         for (i = 0; i < count; ++i)
1562                                 if (charptr_tmp[(i + index) >> 3] &
1563                                                 (1 << ((i + index) & 7)))
1564                                         long_tmp |= (1L << i);
1565
1566                         stack[stack_ptr - 1] = long_tmp;
1567
1568                         break;
1569                 case OP_DYNA:
1570                         /*
1571                          * Dynamically change size of array
1572                          * ...argument 0 is variable ID
1573                          * ...stack 0 is new size
1574                          */
1575                         if (!altera_check_stack(stack_ptr, 1, &status))
1576                                 break;
1577                         variable_id = args[0];
1578                         long_tmp = stack[--stack_ptr];
1579
1580                         if (long_tmp > var_size[variable_id]) {
1581                                 var_size[variable_id] = long_tmp;
1582
1583                                 if (attrs[variable_id] & 0x10)
1584                                         /* allocate integer array */
1585                                         long_tmp *= sizeof(long);
1586                                 else
1587                                         /* allocate Boolean array */
1588                                         long_tmp = (long_tmp + 7) >> 3;
1589
1590                                 /*
1591                                  * If the buffer was previously allocated,
1592                                  * free it
1593                                  */
1594                                 if (attrs[variable_id] & 0x80) {
1595                                         kfree((void *)vars[variable_id]);
1596                                         vars[variable_id] = 0;
1597                                 }
1598
1599                                 /*
1600                                  * Allocate a new buffer
1601                                  * of the requested size
1602                                  */
1603                                 vars[variable_id] = (long)
1604                                         kzalloc(long_tmp, GFP_KERNEL);
1605
1606                                 if (vars[variable_id] == 0) {
1607                                         status = -ENOMEM;
1608                                         break;
1609                                 }
1610
1611                                 /*
1612                                  * Set the attribute bit to indicate that
1613                                  * this buffer was dynamically allocated and
1614                                  * should be freed later
1615                                  */
1616                                 attrs[variable_id] |= 0x80;
1617
1618                                 /* zero out memory */
1619                                 count = ((var_size[variable_id] + 7L) /
1620                                                                         8L);
1621                                 charptr_tmp = (u8 *)(vars[variable_id]);
1622                                 for (index = 0; index < count; ++index)
1623                                         charptr_tmp[index] = 0;
1624
1625                         }
1626
1627                         break;
1628                 case OP_EXPV:
1629                         /*
1630                          * Export Boolean array
1631                          * ...argument 0 is string ID
1632                          * ...stack 0 is variable ID
1633                          * ...stack 1 is array right index
1634                          * ...stack 2 is array left index
1635                          */
1636                         if (!altera_check_stack(stack_ptr, 3, &status))
1637                                 break;
1638                         if (version == 0) {
1639                                 /* EXPV is not supported in JBC 1.0 */
1640                                 bad_opcode = 1;
1641                                 break;
1642                         }
1643                         name = &p[str_table + args[0]];
1644                         variable_id = stack[--stack_ptr];
1645                         long_idx = stack[--stack_ptr];/* right indx */
1646                         long_idx2 = stack[--stack_ptr];/* left indx */
1647
1648                         if (long_idx > long_idx2) {
1649                                 /* reverse indices not supported */
1650                                 status = -ERANGE;
1651                                 break;
1652                         }
1653
1654                         long_count = 1 + long_idx2 - long_idx;
1655
1656                         charptr_tmp = (u8 *)vars[variable_id];
1657                         charptr_tmp2 = NULL;
1658
1659                         if ((long_idx & 7L) != 0) {
1660                                 s32 k = long_idx;
1661                                 charptr_tmp2 =
1662                                         kzalloc(((long_count + 7L) / 8L),
1663                                                         GFP_KERNEL);
1664                                 if (charptr_tmp2 == NULL) {
1665                                         status = -ENOMEM;
1666                                         break;
1667                                 }
1668
1669                                 for (i = 0; i < long_count; ++i) {
1670                                         if (charptr_tmp[k >> 3] &
1671                                                         (1 << (k & 7)))
1672                                                 charptr_tmp2[i >> 3] |=
1673                                                                 (1 << (i & 7));
1674                                         else
1675                                                 charptr_tmp2[i >> 3] &=
1676                                                                 ~(1 << (i & 7));
1677
1678                                         ++k;
1679                                 }
1680                                 charptr_tmp = charptr_tmp2;
1681
1682                         } else if (long_idx != 0)
1683                                 charptr_tmp = &charptr_tmp[long_idx >> 3];
1684
1685                         altera_export_bool_array(name, charptr_tmp,
1686                                                         long_count);
1687
1688                         /* free allocated buffer */
1689                         if ((long_idx & 7L) != 0)
1690                                 kfree(charptr_tmp2);
1691
1692                         break;
1693                 case OP_COPY: {
1694                         /*
1695                          * Array copy
1696                          * ...argument 0 is dest ID
1697                          * ...argument 1 is source ID
1698                          * ...stack 0 is count
1699                          * ...stack 1 is dest index
1700                          * ...stack 2 is source index
1701                          */
1702                         s32 copy_count;
1703                         s32 copy_index;
1704                         s32 copy_index2;
1705                         s32 destleft;
1706                         s32 src_count;
1707                         s32 dest_count;
1708                         int src_reverse = 0;
1709                         int dest_reverse = 0;
1710
1711                         if (!altera_check_stack(stack_ptr, 3, &status))
1712                                 break;
1713
1714                         copy_count = stack[--stack_ptr];
1715                         copy_index = stack[--stack_ptr];
1716                         copy_index2 = stack[--stack_ptr];
1717                         reverse = 0;
1718
1719                         if (version > 0) {
1720                                 /*
1721                                  * stack 0 = source right index
1722                                  * stack 1 = source left index
1723                                  * stack 2 = destination right index
1724                                  * stack 3 = destination left index
1725                                  */
1726                                 destleft = stack[--stack_ptr];
1727
1728                                 if (copy_count > copy_index) {
1729                                         src_reverse = 1;
1730                                         reverse = 1;
1731                                         src_count = 1 + copy_count - copy_index;
1732                                         /* copy_index = source start index */
1733                                 } else {
1734                                         src_count = 1 + copy_index - copy_count;
1735                                         /* source start index */
1736                                         copy_index = copy_count;
1737                                 }
1738
1739                                 if (copy_index2 > destleft) {
1740                                         dest_reverse = 1;
1741                                         reverse = !reverse;
1742                                         dest_count = 1 + copy_index2 - destleft;
1743                                         /* destination start index */
1744                                         copy_index2 = destleft;
1745                                 } else
1746                                         dest_count = 1 + destleft - copy_index2;
1747
1748                                 copy_count = (src_count < dest_count) ?
1749                                                         src_count : dest_count;
1750
1751                                 if ((src_reverse || dest_reverse) &&
1752                                         (src_count != dest_count))
1753                                         /*
1754                                          * If either the source or destination
1755                                          * is reversed, we can't tolerate
1756                                          * a length mismatch, because we
1757                                          * "left justify" arrays when copying.
1758                                          * This won't work correctly
1759                                          * with reversed arrays.
1760                                          */
1761                                         status = -ERANGE;
1762
1763                         }
1764
1765                         count = copy_count;
1766                         index = copy_index;
1767                         index2 = copy_index2;
1768
1769                         /*
1770                          * If destination is a read-only array,
1771                          * allocate a buffer and convert it to a writable array
1772                          */
1773                         variable_id = args[1];
1774                         if ((version > 0) &&
1775                                 ((attrs[variable_id] & 0x9c) == 0x0c)) {
1776                                 /* Allocate a writable buffer for this array */
1777                                 long_tmp =
1778                                         (var_size[variable_id] + 7L) >> 3L;
1779                                 charptr_tmp2 = (u8 *)vars[variable_id];
1780                                 charptr_tmp =
1781                                         kzalloc(long_tmp, GFP_KERNEL);
1782                                 vars[variable_id] = (long)charptr_tmp;
1783
1784                                 if (vars[variable_id] == 0) {
1785                                         status = -ENOMEM;
1786                                         break;
1787                                 }
1788
1789                                 /* zero the buffer */
1790                                 for (long_idx = 0L; long_idx < long_tmp;
1791                                                                 ++long_idx)
1792                                         charptr_tmp[long_idx] = 0;
1793
1794                                 /* copy previous contents into buffer */
1795                                 for (long_idx = 0L;
1796                                         long_idx < var_size[variable_id];
1797                                                                 ++long_idx) {
1798                                         long_idx2 = long_idx;
1799
1800                                         if (charptr_tmp2[long_idx2 >> 3] &
1801                                                 (1 << (long_idx2 & 7)))
1802                                                 charptr_tmp[long_idx >> 3] |=
1803                                                         (1 << (long_idx & 7));
1804
1805                                 }
1806
1807                                 /*
1808                                 set bit 7 - buffer was dynamically allocated */
1809                                 attrs[variable_id] |= 0x80;
1810
1811                                 /* clear bit 2 - variable is writable */
1812                                 attrs[variable_id] &= ~0x04;
1813                                 attrs[variable_id] |= 0x01;
1814                         }
1815
1816                         charptr_tmp = (u8 *)vars[args[1]];
1817                         charptr_tmp2 = (u8 *)vars[args[0]];
1818
1819                         /* check if destination is a writable Boolean array */
1820                         if ((attrs[args[1]] & 0x1c) != 0x08) {
1821                                 status = -ERANGE;
1822                                 break;
1823                         }
1824
1825                         if (count < 1) {
1826                                 status = -ERANGE;
1827                                 break;
1828                         }
1829
1830                         if (reverse)
1831                                 index2 += (count - 1);
1832
1833                         for (i = 0; i < count; ++i) {
1834                                 if (charptr_tmp2[index >> 3] &
1835                                                         (1 << (index & 7)))
1836                                         charptr_tmp[index2 >> 3] |=
1837                                                         (1 << (index2 & 7));
1838                                 else
1839                                         charptr_tmp[index2 >> 3] &=
1840                                                 ~(1 << (index2 & 7));
1841
1842                                 ++index;
1843                                 if (reverse)
1844                                         --index2;
1845                                 else
1846                                         ++index2;
1847                         }
1848
1849                         break;
1850                 }
1851                 case OP_DSC:
1852                 case OP_ISC: {
1853                         /*
1854                          * DRSCAN with capture
1855                          * IRSCAN with capture
1856                          * ...argument 0 is scan data variable ID
1857                          * ...argument 1 is capture variable ID
1858                          * ...stack 0 is capture index
1859                          * ...stack 1 is scan data index
1860                          * ...stack 2 is count
1861                          */
1862                         s32 scan_right, scan_left;
1863                         s32 capture_count = 0;
1864                         s32 scan_count = 0;
1865                         s32 capture_index;
1866                         s32 scan_index;
1867
1868                         if (!altera_check_stack(stack_ptr, 3, &status))
1869                                 break;
1870
1871                         capture_index = stack[--stack_ptr];
1872                         scan_index = stack[--stack_ptr];
1873
1874                         if (version > 0) {
1875                                 /*
1876                                  * stack 0 = capture right index
1877                                  * stack 1 = capture left index
1878                                  * stack 2 = scan right index
1879                                  * stack 3 = scan left index
1880                                  * stack 4 = count
1881                                  */
1882                                 scan_right = stack[--stack_ptr];
1883                                 scan_left = stack[--stack_ptr];
1884                                 capture_count = 1 + scan_index - capture_index;
1885                                 scan_count = 1 + scan_left - scan_right;
1886                                 scan_index = scan_right;
1887                         }
1888
1889                         long_count = stack[--stack_ptr];
1890                         /*
1891                          * If capture array is read-only, allocate a buffer
1892                          * and convert it to a writable array
1893                          */
1894                         variable_id = args[1];
1895                         if ((version > 0) &&
1896                                 ((attrs[variable_id] & 0x9c) == 0x0c)) {
1897                                 /* Allocate a writable buffer for this array */
1898                                 long_tmp =
1899                                         (var_size[variable_id] + 7L) >> 3L;
1900                                 charptr_tmp2 = (u8 *)vars[variable_id];
1901                                 charptr_tmp =
1902                                         kzalloc(long_tmp, GFP_KERNEL);
1903                                 vars[variable_id] = (long)charptr_tmp;
1904
1905                                 if (vars[variable_id] == 0) {
1906                                         status = -ENOMEM;
1907                                         break;
1908                                 }
1909
1910                                 /* zero the buffer */
1911                                 for (long_idx = 0L; long_idx < long_tmp;
1912                                                                 ++long_idx)
1913                                         charptr_tmp[long_idx] = 0;
1914
1915                                 /* copy previous contents into buffer */
1916                                 for (long_idx = 0L;
1917                                         long_idx < var_size[variable_id];
1918                                                                 ++long_idx) {
1919                                         long_idx2 = long_idx;
1920
1921                                         if (charptr_tmp2[long_idx2 >> 3] &
1922                                                 (1 << (long_idx2 & 7)))
1923                                                 charptr_tmp[long_idx >> 3] |=
1924                                                         (1 << (long_idx & 7));
1925
1926                                 }
1927
1928                                 /*
1929                                  * set bit 7 - buffer was
1930                                  * dynamically allocated
1931                                  */
1932                                 attrs[variable_id] |= 0x80;
1933
1934                                 /* clear bit 2 - variable is writable */
1935                                 attrs[variable_id] &= ~0x04;
1936                                 attrs[variable_id] |= 0x01;
1937
1938                         }
1939
1940                         charptr_tmp = (u8 *)vars[args[0]];
1941                         charptr_tmp2 = (u8 *)vars[args[1]];
1942
1943                         if ((version > 0) &&
1944                                         ((long_count > capture_count) ||
1945                                         (long_count > scan_count))) {
1946                                 status = -ERANGE;
1947                                 break;
1948                         }
1949
1950                         /*
1951                          * check that capture array
1952                          * is a writable Boolean array
1953                          */
1954                         if ((attrs[args[1]] & 0x1c) != 0x08) {
1955                                 status = -ERANGE;
1956                                 break;
1957                         }
1958
1959                         if (status == 0) {
1960                                 if (opcode == 0x82) /* DSC */
1961                                         status = altera_swap_dr(astate,
1962                                                         long_count,
1963                                                         charptr_tmp,
1964                                                         scan_index,
1965                                                         charptr_tmp2,
1966                                                         capture_index);
1967                                 else /* ISC */
1968                                         status = altera_swap_ir(astate,
1969                                                         long_count,
1970                                                         charptr_tmp,
1971                                                         scan_index,
1972                                                         charptr_tmp2,
1973                                                         capture_index);
1974
1975                         }
1976
1977                         break;
1978                 }
1979                 case OP_WAIT:
1980                         /*
1981                          * WAIT
1982                          * ...argument 0 is wait state
1983                          * ...argument 1 is end state
1984                          * ...stack 0 is cycles
1985                          * ...stack 1 is microseconds
1986                          */
1987                         if (!altera_check_stack(stack_ptr, 2, &status))
1988                                 break;
1989                         long_tmp = stack[--stack_ptr];
1990
1991                         if (long_tmp != 0L)
1992                                 status = altera_wait_cycles(astate, long_tmp,
1993                                                                 args[0]);
1994
1995                         long_tmp = stack[--stack_ptr];
1996
1997                         if ((status == 0) && (long_tmp != 0L))
1998                                 status = altera_wait_msecs(astate,
1999                                                                 long_tmp,
2000                                                                 args[0]);
2001
2002                         if ((status == 0) && (args[1] != args[0]))
2003                                 status = altera_goto_jstate(astate,
2004                                                                 args[1]);
2005
2006                         if (version > 0) {
2007                                 --stack_ptr; /* throw away MAX cycles */
2008                                 --stack_ptr; /* throw away MAX microseconds */
2009                         }
2010                         break;
2011                 case OP_CMPA: {
2012                         /*
2013                          * Array compare
2014                          * ...argument 0 is source 1 ID
2015                          * ...argument 1 is source 2 ID
2016                          * ...argument 2 is mask ID
2017                          * ...stack 0 is source 1 index
2018                          * ...stack 1 is source 2 index
2019                          * ...stack 2 is mask index
2020                          * ...stack 3 is count
2021                          */
2022                         s32 a, b;
2023                         u8 *source1 = (u8 *)vars[args[0]];
2024                         u8 *source2 = (u8 *)vars[args[1]];
2025                         u8 *mask = (u8 *)vars[args[2]];
2026                         u32 index1;
2027                         u32 index2;
2028                         u32 mask_index;
2029
2030                         if (!altera_check_stack(stack_ptr, 4, &status))
2031                                 break;
2032
2033                         index1 = stack[--stack_ptr];
2034                         index2 = stack[--stack_ptr];
2035                         mask_index = stack[--stack_ptr];
2036                         long_count = stack[--stack_ptr];
2037
2038                         if (version > 0) {
2039                                 /*
2040                                  * stack 0 = source 1 right index
2041                                  * stack 1 = source 1 left index
2042                                  * stack 2 = source 2 right index
2043                                  * stack 3 = source 2 left index
2044                                  * stack 4 = mask right index
2045                                  * stack 5 = mask left index
2046                                  */
2047                                 s32 mask_right = stack[--stack_ptr];
2048                                 s32 mask_left = stack[--stack_ptr];
2049                                 /* source 1 count */
2050                                 a = 1 + index2 - index1;
2051                                 /* source 2 count */
2052                                 b = 1 + long_count - mask_index;
2053                                 a = (a < b) ? a : b;
2054                                 /* mask count */
2055                                 b = 1 + mask_left - mask_right;
2056                                 a = (a < b) ? a : b;
2057                                 /* source 2 start index */
2058                                 index2 = mask_index;
2059                                 /* mask start index */
2060                                 mask_index = mask_right;
2061                                 long_count = a;
2062                         }
2063
2064                         long_tmp = 1L;
2065
2066                         if (long_count < 1)
2067                                 status = -ERANGE;
2068                         else {
2069                                 count = long_count;
2070
2071                                 for (i = 0; i < count; ++i) {
2072                                         if (mask[mask_index >> 3] &
2073                                                 (1 << (mask_index & 7))) {
2074                                                 a = source1[index1 >> 3] &
2075                                                         (1 << (index1 & 7))
2076                                                                 ? 1 : 0;
2077                                                 b = source2[index2 >> 3] &
2078                                                         (1 << (index2 & 7))
2079                                                                 ? 1 : 0;
2080
2081                                                 if (a != b) /* failure */
2082                                                         long_tmp = 0L;
2083                                         }
2084                                         ++index1;
2085                                         ++index2;
2086                                         ++mask_index;
2087                                 }
2088                         }
2089
2090                         stack[stack_ptr++] = long_tmp;
2091
2092                         break;
2093                 }
2094                 default:
2095                         /* Unrecognized opcode -- ERROR! */
2096                         bad_opcode = 1;
2097                         break;
2098                 }
2099
2100                 if (bad_opcode)
2101                         status = -ENOSYS;
2102
2103                 if ((stack_ptr < 0) || (stack_ptr >= ALTERA_STACK_SIZE))
2104                         status = -EOVERFLOW;
2105
2106                 if (status != 0) {
2107                         done = 1;
2108                         *error_address = (s32)(opcode_address - code_sect);
2109                 }
2110         }
2111
2112         altera_free_buffers(astate);
2113
2114         /* Free all dynamically allocated arrays */
2115         if ((attrs != NULL) && (vars != NULL))
2116                 for (i = 0; i < sym_count; ++i)
2117                         if (attrs[i] & 0x80)
2118                                 kfree((void *)vars[i]);
2119
2120         kfree(vars);
2121         kfree(var_size);
2122         kfree(attrs);
2123         kfree(proc_attributes);
2124
2125         return status;
2126 }
2127
2128 static int altera_get_note(u8 *p, s32 program_size,
2129                         s32 *offset, char *key, char *value, int length)
2130 /*
2131  * Gets key and value of NOTE fields in the JBC file.
2132  * Can be called in two modes:  if offset pointer is NULL,
2133  * then the function searches for note fields which match
2134  * the key string provided.  If offset is not NULL, then
2135  * the function finds the next note field of any key,
2136  * starting at the offset specified by the offset pointer.
2137  * Returns 0 for success, else appropriate error code
2138  */
2139 {
2140         int status = -ENODATA;
2141         u32 note_strings = 0L;
2142         u32 note_table = 0L;
2143         u32 note_count = 0L;
2144         u32 first_word = 0L;
2145         int version = 0;
2146         int delta = 0;
2147         char *key_ptr;
2148         char *value_ptr;
2149         int i;
2150
2151         /* Read header information */
2152         if (program_size > 52L) {
2153                 first_word    = get_unaligned_be32(&p[0]);
2154                 version = (first_word & 1L);
2155                 delta = version * 8;
2156
2157                 note_strings  = get_unaligned_be32(&p[8 + delta]);
2158                 note_table    = get_unaligned_be32(&p[12 + delta]);
2159                 note_count    = get_unaligned_be32(&p[44 + (2 * delta)]);
2160         }
2161
2162         if ((first_word != 0x4A414D00L) && (first_word != 0x4A414D01L))
2163                 return -EIO;
2164
2165         if (note_count <= 0L)
2166                 return status;
2167
2168         if (offset == NULL) {
2169                 /*
2170                  * We will search for the first note with a specific key,
2171                  * and return only the value
2172                  */
2173                 for (i = 0; (i < note_count) &&
2174                                                 (status != 0); ++i) {
2175                         key_ptr = &p[note_strings +
2176                                         get_unaligned_be32(
2177                                         &p[note_table + (8 * i)])];
2178                         if ((strnicmp(key, key_ptr, strlen(key_ptr)) == 0) &&
2179                                                 (key != NULL)) {
2180                                 status = 0;
2181
2182                                 value_ptr = &p[note_strings +
2183                                                 get_unaligned_be32(
2184                                                 &p[note_table + (8 * i) + 4])];
2185
2186                                 if (value != NULL)
2187                                         strlcpy(value, value_ptr, length);
2188
2189                         }
2190                 }
2191         } else {
2192                 /*
2193                  * We will search for the next note, regardless of the key,
2194                  * and return both the value and the key
2195                  */
2196
2197                 i = *offset;
2198
2199                 if ((i >= 0) && (i < note_count)) {
2200                         status = 0;
2201
2202                         if (key != NULL)
2203                                 strlcpy(key, &p[note_strings +
2204                                                 get_unaligned_be32(
2205                                                 &p[note_table + (8 * i)])],
2206                                         length);
2207
2208                         if (value != NULL)
2209                                 strlcpy(value, &p[note_strings +
2210                                                 get_unaligned_be32(
2211                                                 &p[note_table + (8 * i) + 4])],
2212                                         length);
2213
2214                         *offset = i + 1;
2215                 }
2216         }
2217
2218         return status;
2219 }
2220
2221 static int altera_check_crc(u8 *p, s32 program_size)
2222 {
2223         int status = 0;
2224         u16 local_expected = 0,
2225             local_actual = 0,
2226             shift_reg = 0xffff;
2227         int bit, feedback;
2228         u8 databyte;
2229         u32 i;
2230         u32 crc_section = 0L;
2231         u32 first_word = 0L;
2232         int version = 0;
2233         int delta = 0;
2234
2235         if (program_size > 52L) {
2236                 first_word  = get_unaligned_be32(&p[0]);
2237                 version = (first_word & 1L);
2238                 delta = version * 8;
2239
2240                 crc_section = get_unaligned_be32(&p[32 + delta]);
2241         }
2242
2243         if ((first_word != 0x4A414D00L) && (first_word != 0x4A414D01L))
2244                 status = -EIO;
2245
2246         if (crc_section >= program_size)
2247                 status = -EIO;
2248
2249         if (status == 0) {
2250                 local_expected = (u16)get_unaligned_be16(&p[crc_section]);
2251
2252                 for (i = 0; i < crc_section; ++i) {
2253                         databyte = p[i];
2254                         for (bit = 0; bit < 8; bit++) {
2255                                 feedback = (databyte ^ shift_reg) & 0x01;
2256                                 shift_reg >>= 1;
2257                                 if (feedback)
2258                                         shift_reg ^= 0x8408;
2259
2260                                 databyte >>= 1;
2261                         }
2262                 }
2263
2264                 local_actual = (u16)~shift_reg;
2265
2266                 if (local_expected != local_actual)
2267                         status = -EILSEQ;
2268
2269         }
2270
2271         if (debug || status) {
2272                 switch (status) {
2273                 case 0:
2274                         printk(KERN_INFO "%s: CRC matched: %04x\n", __func__,
2275                                 local_actual);
2276                         break;
2277                 case -EILSEQ:
2278                         printk(KERN_ERR "%s: CRC mismatch: expected %04x, "
2279                                 "actual %04x\n", __func__, local_expected,
2280                                 local_actual);
2281                         break;
2282                 case -ENODATA:
2283                         printk(KERN_ERR "%s: expected CRC not found, "
2284                                 "actual CRC = %04x\n", __func__,
2285                                 local_actual);
2286                         break;
2287                 case -EIO:
2288                         printk(KERN_ERR "%s: error: format isn't "
2289                                 "recognized.\n", __func__);
2290                         break;
2291                 default:
2292                         printk(KERN_ERR "%s: CRC function returned error "
2293                                 "code %d\n", __func__, status);
2294                         break;
2295                 }
2296         }
2297
2298         return status;
2299 }
2300
2301 static int altera_get_file_info(u8 *p,
2302                                         s32 program_size,
2303                                         int *format_version,
2304                                         int *action_count,
2305                                         int *procedure_count)
2306 {
2307         int status = -EIO;
2308         u32 first_word = 0;
2309         int version = 0;
2310
2311         if (program_size <= 52L)
2312                 return status;
2313
2314         first_word = get_unaligned_be32(&p[0]);
2315
2316         if ((first_word == 0x4A414D00L) || (first_word == 0x4A414D01L)) {
2317                 status = 0;
2318
2319                 version = (first_word & 1L);
2320                 *format_version = version + 1;
2321
2322                 if (version > 0) {
2323                         *action_count = get_unaligned_be32(&p[48]);
2324                         *procedure_count = get_unaligned_be32(&p[52]);
2325                 }
2326         }
2327
2328         return status;
2329 }
2330
2331 static int altera_get_act_info(u8 *p,
2332                                         s32 program_size,
2333                                         int index,
2334                                         char **name,
2335                                         char **description,
2336                                         struct altera_procinfo **proc_list)
2337 {
2338         int status = -EIO;
2339         struct altera_procinfo *procptr = NULL;
2340         struct altera_procinfo *tmpptr = NULL;
2341         u32 first_word = 0L;
2342         u32 action_table = 0L;
2343         u32 proc_table = 0L;
2344         u32 str_table = 0L;
2345         u32 note_strings = 0L;
2346         u32 action_count = 0L;
2347         u32 proc_count = 0L;
2348         u32 act_name_id = 0L;
2349         u32 act_desc_id = 0L;
2350         u32 act_proc_id = 0L;
2351         u32 act_proc_name = 0L;
2352         u8 act_proc_attribute = 0;
2353
2354         if (program_size <= 52L)
2355                 return status;
2356         /* Read header information */
2357         first_word = get_unaligned_be32(&p[0]);
2358
2359         if (first_word != 0x4A414D01L)
2360                 return status;
2361
2362         action_table = get_unaligned_be32(&p[4]);
2363         proc_table   = get_unaligned_be32(&p[8]);
2364         str_table = get_unaligned_be32(&p[12]);
2365         note_strings = get_unaligned_be32(&p[16]);
2366         action_count = get_unaligned_be32(&p[48]);
2367         proc_count   = get_unaligned_be32(&p[52]);
2368
2369         if (index >= action_count)
2370                 return status;
2371
2372         act_name_id = get_unaligned_be32(&p[action_table + (12 * index)]);
2373         act_desc_id = get_unaligned_be32(&p[action_table + (12 * index) + 4]);
2374         act_proc_id = get_unaligned_be32(&p[action_table + (12 * index) + 8]);
2375
2376         *name = &p[str_table + act_name_id];
2377
2378         if (act_desc_id < (note_strings - str_table))
2379                 *description = &p[str_table + act_desc_id];
2380
2381         do {
2382                 act_proc_name = get_unaligned_be32(
2383                                         &p[proc_table + (13 * act_proc_id)]);
2384                 act_proc_attribute =
2385                         (p[proc_table + (13 * act_proc_id) + 8] & 0x03);
2386
2387                 procptr = (struct altera_procinfo *)
2388                                 kzalloc(sizeof(struct altera_procinfo),
2389                                                                 GFP_KERNEL);
2390
2391                 if (procptr == NULL)
2392                         status = -ENOMEM;
2393                 else {
2394                         procptr->name = &p[str_table + act_proc_name];
2395                         procptr->attrs = act_proc_attribute;
2396                         procptr->next = NULL;
2397
2398                         /* add record to end of linked list */
2399                         if (*proc_list == NULL)
2400                                 *proc_list = procptr;
2401                         else {
2402                                 tmpptr = *proc_list;
2403                                 while (tmpptr->next != NULL)
2404                                         tmpptr = tmpptr->next;
2405                                 tmpptr->next = procptr;
2406                         }
2407                 }
2408
2409                 act_proc_id = get_unaligned_be32(
2410                                 &p[proc_table + (13 * act_proc_id) + 4]);
2411         } while ((act_proc_id != 0) && (act_proc_id < proc_count));
2412
2413         return status;
2414 }
2415
2416 int altera_init(struct altera_config *config, const struct firmware *fw)
2417 {
2418         struct altera_state *astate = NULL;
2419         struct altera_procinfo *proc_list = NULL;
2420         struct altera_procinfo *procptr = NULL;
2421         char *key = NULL;
2422         char *value = NULL;
2423         char *action_name = NULL;
2424         char *description = NULL;
2425         int exec_result = 0;
2426         int exit_code = 0;
2427         int format_version = 0;
2428         int action_count = 0;
2429         int procedure_count = 0;
2430         int index = 0;
2431         s32 offset = 0L;
2432         s32 error_address = 0L;
2433         int retval = 0;
2434
2435         key = kzalloc(33, GFP_KERNEL);
2436         if (!key) {
2437                 retval = -ENOMEM;
2438                 goto out;
2439         }
2440         value = kzalloc(257, GFP_KERNEL);
2441         if (!value) {
2442                 retval = -ENOMEM;
2443                 goto free_key;
2444         }
2445         astate = kzalloc(sizeof(struct altera_state), GFP_KERNEL);
2446         if (!astate) {
2447                 retval = -ENOMEM;
2448                 goto free_value;
2449         }
2450
2451         astate->config = config;
2452         if (!astate->config->jtag_io) {
2453                 dprintk(KERN_INFO "%s: using byteblaster!\n", __func__);
2454                 astate->config->jtag_io = netup_jtag_io_lpt;
2455         }
2456
2457         altera_check_crc((u8 *)fw->data, fw->size);
2458
2459         if (debug) {
2460                 altera_get_file_info((u8 *)fw->data, fw->size, &format_version,
2461                                         &action_count, &procedure_count);
2462                 printk(KERN_INFO "%s: File format is %s ByteCode format\n",
2463                         __func__, (format_version == 2) ? "Jam STAPL" :
2464                                                 "pre-standardized Jam 1.1");
2465                 while (altera_get_note((u8 *)fw->data, fw->size,
2466                                         &offset, key, value, 256) == 0)
2467                         printk(KERN_INFO "%s: NOTE \"%s\" = \"%s\"\n",
2468                                         __func__, key, value);
2469         }
2470
2471         if (debug && (format_version == 2) && (action_count > 0)) {
2472                 printk(KERN_INFO "%s: Actions available:\n", __func__);
2473                 for (index = 0; index < action_count; ++index) {
2474                         altera_get_act_info((u8 *)fw->data, fw->size,
2475                                                 index, &action_name,
2476                                                 &description,
2477                                                 &proc_list);
2478
2479                         if (description == NULL)
2480                                 printk(KERN_INFO "%s: %s\n",
2481                                                 __func__,
2482                                                 action_name);
2483                         else
2484                                 printk(KERN_INFO "%s: %s \"%s\"\n",
2485                                                 __func__,
2486                                                 action_name,
2487                                                 description);
2488
2489                         procptr = proc_list;
2490                         while (procptr != NULL) {
2491                                 if (procptr->attrs != 0)
2492                                         printk(KERN_INFO "%s:    %s (%s)\n",
2493                                                 __func__,
2494                                                 procptr->name,
2495                                                 (procptr->attrs == 1) ?
2496                                                 "optional" : "recommended");
2497
2498                                 proc_list = procptr->next;
2499                                 kfree(procptr);
2500                                 procptr = proc_list;
2501                         }
2502                 }
2503
2504                 printk(KERN_INFO "\n");
2505         }
2506
2507         exec_result = altera_execute(astate, (u8 *)fw->data, fw->size,
2508                                 &error_address, &exit_code, &format_version);
2509
2510         if (exit_code)
2511                 exec_result = -EREMOTEIO;
2512
2513         if ((format_version == 2) && (exec_result == -EINVAL)) {
2514                 if (astate->config->action == NULL)
2515                         printk(KERN_ERR "%s: error: no action specified for "
2516                                 "Jam STAPL file.\nprogram terminated.\n",
2517                                 __func__);
2518                 else
2519                         printk(KERN_ERR "%s: error: action \"%s\""
2520                                 " is not supported "
2521                                 "for this Jam STAPL file.\n"
2522                                 "Program terminated.\n", __func__,
2523                                 astate->config->action);
2524
2525         } else if (exec_result)
2526                 printk(KERN_ERR "%s: error %d\n", __func__, exec_result);
2527
2528         kfree(astate);
2529 free_value:
2530         kfree(value);
2531 free_key:
2532         kfree(key);
2533 out:
2534         return retval;
2535 }
2536 EXPORT_SYMBOL(altera_init);