zcy
/
tinyriscv-openocd
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Pavel Chromy style fixes. 

git-svn-id: svn://svn.berlios.de/openocd/trunk@344 b42882b7-edfa-0310-969c-e2dbd0fdcd60
__archive__
oharboe 2008-02-25 14:58:20 +00:00
parent 81184adfb0
commit a08d86e88d
3 changed files with 1147 additions and 1148 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

200
src/flash/at91sam7.h
View File

@ -1,100 +1,100 @@
/*************************************************************************** /***************************************************************************
* Copyright (C) 2006 by Magnus Lundin * * Copyright (C) 2006 by Magnus Lundin *
* lundin@mlu.mine.nu * * lundin@mlu.mine.nu *
* * * *
* This program is free software; you can redistribute it and/or modify * * This program is free software; you can redistribute it and/or modify *
* it under the terms of the GNU General Public License as published by * * it under the terms of the GNU General Public License as published by *
* the Free Software Foundation; either version 2 of the License, or * * the Free Software Foundation; either version 2 of the License, or *
* (at your option) any later version. * * (at your option) any later version. *
* * * *
* This program is distributed in the hope that it will be useful, * * This program is distributed in the hope that it will be useful, *
* but WITHOUT ANY WARRANTY; without even the implied warranty of * * but WITHOUT ANY WARRANTY; without even the implied warranty of *
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
* GNU General Public License for more details. * * GNU General Public License for more details. *
* * * *
* You should have received a copy of the GNU General Public License * * You should have received a copy of the GNU General Public License *
* along with this program; if not, write to the * * along with this program; if not, write to the *
* Free Software Foundation, Inc., * * Free Software Foundation, Inc., *
* 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. * * 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. *
***************************************************************************/ ***************************************************************************/
#ifndef AT91SAM7_H #ifndef AT91SAM7_H
#define AT91SAM7_H #define AT91SAM7_H
#include "flash.h" #include "flash.h"
#include "target.h" #include "target.h"
typedef struct at91sam7_flash_bank_s typedef struct at91sam7_flash_bank_s
{ {
u32 working_area; u32 working_area;
u32 working_area_size; u32 working_area_size;
/* chip id register */ /* chip id register */
u32 cidr; u32 cidr;
u16 cidr_ext; u16 cidr_ext;
u16 cidr_nvptyp; u16 cidr_nvptyp;
u16 cidr_arch; u16 cidr_arch;
u16 cidr_sramsiz; u16 cidr_sramsiz;
u16 cidr_nvpsiz; u16 cidr_nvpsiz;
u16 cidr_nvpsiz2; u16 cidr_nvpsiz2;
u16 cidr_eproc; u16 cidr_eproc;
u16 cidr_version; u16 cidr_version;
char * target_name; char * target_name;
/* flash geometry */ /* flash geometry */
u16 num_pages; u16 num_pages;
u16 pagesize; u16 pagesize;
u16 pages_in_lockregion; u16 pages_in_lockregion;
u8 num_erase_regions; u8 num_erase_regions;
u8 num_planes; u8 num_planes;
u32 *erase_region_info; u32 *erase_region_info;
/* nv memory bits */ /* nv memory bits */
u16 num_lockbits; u16 num_lockbits;
u16 lockbits[4]; u16 lockbits[4];
u16 num_nvmbits; u16 num_nvmbits;
u16 nvmbits; u16 nvmbits;
u8 securitybit; u8 securitybit;
u8 flashmode[4]; /* 0: not init, 1: fmcn for nvbits (1uS), 2: fmcn for flash (1.5uS) */ u8 flashmode[4]; /* 0: not init, 1: fmcn for nvbits (1uS), 2: fmcn for flash (1.5uS) */
/* main clock status */ /* main clock status */
u8 mck_valid; u8 mck_valid;
u32 mck_freq; u32 mck_freq;
int probed; int probed;
} at91sam7_flash_bank_t; } at91sam7_flash_bank_t;
/* AT91SAM7 control registers */ /* AT91SAM7 control registers */
#define DBGU_CIDR 0xFFFFF240 #define DBGU_CIDR 0xFFFFF240
#define CKGR_MCFR 0xFFFFFC24 #define CKGR_MCFR 0xFFFFFC24
#define CKGR_MCFR_MAINRDY 0x10000 #define CKGR_MCFR_MAINRDY 0x10000
#define CKGR_PLLR 0xFFFFFC2c #define CKGR_PLLR 0xFFFFFC2c
#define CKGR_PLLR_DIV 0xff #define CKGR_PLLR_DIV 0xff
#define CKGR_PLLR_MUL 0x07ff0000 #define CKGR_PLLR_MUL 0x07ff0000
#define PMC_MCKR 0xFFFFFC30 #define PMC_MCKR 0xFFFFFC30
#define PMC_MCKR_CSS 0x03 #define PMC_MCKR_CSS 0x03
#define PMC_MCKR_PRES 0x1c #define PMC_MCKR_PRES 0x1c
/* Flash Controller Commands */ /* Flash Controller Commands */
#define WP 0x01 #define WP 0x01
#define SLB 0x02 #define SLB 0x02
#define WPL 0x03 #define WPL 0x03
#define CLB 0x04 #define CLB 0x04
#define EA 0x08 #define EA 0x08
#define SGPB 0x0B #define SGPB 0x0B
#define CGPB 0x0D #define CGPB 0x0D
#define SSB 0x0F #define SSB 0x0F
/* MC_FSR bit definitions */ /* MC_FSR bit definitions */
#define MC_FSR_FRDY 1 #define MC_FSR_FRDY 1
#define MC_FSR_EOL 2 #define MC_FSR_EOL 2
/* AT91SAM7 constants */ /* AT91SAM7 constants */
#define RC_FREQ 32000 #define RC_FREQ 32000
/* FLASH_TIMING_MODES */ /* FLASH_TIMING_MODES */
#define FMR_TIMING_NONE 0 #define FMR_TIMING_NONE 0
#define FMR_TIMING_NVBITS 1 #define FMR_TIMING_NVBITS 1
#define FMR_TIMING_FLASH 2 #define FMR_TIMING_FLASH 2
#endif /* AT91SAM7_H */ #endif /* AT91SAM7_H */

732
src/jtag/bitq.c
View File

@ -1,366 +1,366 @@
/*************************************************************************** /***************************************************************************
* Copyright (C) 2007 by Pavel Chromy * * Copyright (C) 2007 by Pavel Chromy *
* chromy@asix.cz * * chromy@asix.cz *
* * * *
* This program is free software; you can redistribute it and/or modify * * This program is free software; you can redistribute it and/or modify *
* it under the terms of the GNU General Public License as published by * * it under the terms of the GNU General Public License as published by *
* the Free Software Foundation; either version 2 of the License, or * * the Free Software Foundation; either version 2 of the License, or *
* (at your option) any later version. * * (at your option) any later version. *
* * * *
* This program is distributed in the hope that it will be useful, * * This program is distributed in the hope that it will be useful, *
* but WITHOUT ANY WARRANTY; without even the implied warranty of * * but WITHOUT ANY WARRANTY; without even the implied warranty of *
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
* GNU General Public License for more details. * * GNU General Public License for more details. *
* * * *
* You should have received a copy of the GNU General Public License * * You should have received a copy of the GNU General Public License *
* along with this program; if not, write to the * * along with this program; if not, write to the *
* Free Software Foundation, Inc., * * Free Software Foundation, Inc., *
* 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. * * 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. *
***************************************************************************/ ***************************************************************************/
#ifdef HAVE_CONFIG_H #ifdef HAVE_CONFIG_H
#include "config.h" #include "config.h"
#endif #endif
#include "bitq.h" #include "bitq.h"
/* project specific includes */ /* project specific includes */
#include "log.h" #include "log.h"
#include "types.h" #include "types.h"
#include "jtag.h" #include "jtag.h"
#include "configuration.h" #include "configuration.h"
/* system includes */ /* system includes */
#include <string.h> #include <string.h>
#include <stdlib.h> #include <stdlib.h>
#include <unistd.h> #include <unistd.h>
#include <sys/time.h> #include <sys/time.h>
#include <time.h> #include <time.h>
bitq_interface_t *bitq_interface; /* low level bit queue interface */ bitq_interface_t *bitq_interface; /* low level bit queue interface */
bitq_state_t bitq_in_state; /* state of input queue */ bitq_state_t bitq_in_state; /* state of input queue */
u8 *bitq_in_buffer; /* buffer dynamically reallocated as needed */ u8 *bitq_in_buffer; /* buffer dynamically reallocated as needed */
unsigned long bitq_in_bufsize=32; /* min. buffer size */ unsigned long bitq_in_bufsize=32; /* min. buffer size */
/* /*
* input queue processing does not use jtag_read_buffer() to avoid unnecessary overhead * input queue processing does not use jtag_read_buffer() to avoid unnecessary overhead
* also the buffer for incomming data is reallocated only if necessary * also the buffer for incomming data is reallocated only if necessary
* no parameters, makes use of stored state information * no parameters, makes use of stored state information
*/ */
void bitq_in_proc(void) void bitq_in_proc(void)
{ {
/* static information preserved between calls to increase performance */ /* static information preserved between calls to increase performance */
static u8 *in_buff; /* pointer to buffer for scanned data */ static u8 *in_buff; /* pointer to buffer for scanned data */
static int in_idx; /* index of byte being scanned */ static int in_idx; /* index of byte being scanned */
static u8 in_mask; /* mask of next bit to be scanned */ static u8 in_mask; /* mask of next bit to be scanned */
scan_field_t *field; scan_field_t *field;
int tdo; int tdo;
/* loop through the queue */ /* loop through the queue */
while (bitq_in_state.cmd) { while (bitq_in_state.cmd) {
/* only JTAG_SCAN command may return data */ /* only JTAG_SCAN command may return data */
if (bitq_in_state.cmd->type==JTAG_SCAN) { if (bitq_in_state.cmd->type==JTAG_SCAN) {
/* loop through the fields */ /* loop through the fields */
while (bitq_in_state.field_idx<bitq_in_state.cmd->cmd.scan->num_fields) { while (bitq_in_state.field_idx<bitq_in_state.cmd->cmd.scan->num_fields) {
field=&bitq_in_state.cmd->cmd.scan->fields[bitq_in_state.field_idx]; field=&bitq_in_state.cmd->cmd.scan->fields[bitq_in_state.field_idx];
if ( field->in_value || field->in_handler) { if ( field->in_value || field->in_handler) {
if (bitq_in_state.bit_pos==0) { if (bitq_in_state.bit_pos==0) {
/* initialize field scanning */ /* initialize field scanning */
in_mask=0x01; in_mask=0x01;
in_idx=0; in_idx=0;
if (field->in_value) in_buff=field->in_value; if (field->in_value) in_buff=field->in_value;
else { else {
/* buffer reallocation needed? */ /* buffer reallocation needed? */
if (field->num_bits>bitq_in_bufsize*8) { if (field->num_bits>bitq_in_bufsize*8) {
/* buffer previously allocated? */ /* buffer previously allocated? */
if (bitq_in_buffer!=NULL) { if (bitq_in_buffer!=NULL) {
/* free it */ /* free it */
free(bitq_in_buffer); free(bitq_in_buffer);
bitq_in_buffer=NULL; bitq_in_buffer=NULL;
} }
/* double the buffer size until it fits */ /* double the buffer size until it fits */
while (field->num_bits>bitq_in_bufsize*8) bitq_in_bufsize*=2; while (field->num_bits>bitq_in_bufsize*8) bitq_in_bufsize*=2;
} }
/* if necessary, allocate buffer and check for malloc error */ /* if necessary, allocate buffer and check for malloc error */
if (bitq_in_buffer==NULL && (bitq_in_buffer=malloc(bitq_in_bufsize))==NULL) { if (bitq_in_buffer==NULL && (bitq_in_buffer=malloc(bitq_in_bufsize))==NULL) {
ERROR("malloc error"); ERROR("malloc error");
exit(-1); exit(-1);
} }
in_buff=(void *)bitq_in_buffer; in_buff=(void *)bitq_in_buffer;
} }
} }
/* field scanning */ /* field scanning */
while (bitq_in_state.bit_pos<field->num_bits) { while (bitq_in_state.bit_pos<field->num_bits) {
if ((tdo=bitq_interface->in())<0) { if ((tdo=bitq_interface->in())<0) {
#ifdef _DEBUG_JTAG_IO_ #ifdef _DEBUG_JTAG_IO_
DEBUG("bitq in EOF"); DEBUG("bitq in EOF");
#endif #endif
return; return;
} }
if (in_mask==0x01) in_buff[in_idx]=0; if (in_mask==0x01) in_buff[in_idx]=0;
if (tdo) in_buff[in_idx]|=in_mask; if (tdo) in_buff[in_idx]|=in_mask;
if (in_mask==0x80) { if (in_mask==0x80) {
in_mask=0x01; in_mask=0x01;
in_idx++; in_idx++;
} }
else in_mask<<=1; else in_mask<<=1;
bitq_in_state.bit_pos++; bitq_in_state.bit_pos++;
} }
if (field->in_handler && bitq_in_state.status==ERROR_OK) { if (field->in_handler && bitq_in_state.status==ERROR_OK) {
bitq_in_state.status=(*field->in_handler)(in_buff, field->in_handler_priv, field); bitq_in_state.status=(*field->in_handler)(in_buff, field->in_handler_priv, field);
} }
} }
bitq_in_state.field_idx++; /* advance to next field */ bitq_in_state.field_idx++; /* advance to next field */
bitq_in_state.bit_pos=0; /* start next field from the first bit */ bitq_in_state.bit_pos=0; /* start next field from the first bit */
} }
} }
bitq_in_state.cmd=bitq_in_state.cmd->next; /* advance to next command */ bitq_in_state.cmd=bitq_in_state.cmd->next; /* advance to next command */
bitq_in_state.field_idx=0; /* preselect first field */ bitq_in_state.field_idx=0; /* preselect first field */
} }
} }
void bitq_io(int tms, int tdi, int tdo_req) void bitq_io(int tms, int tdi, int tdo_req)
{ {
bitq_interface->out(tms, tdi, tdo_req); bitq_interface->out(tms, tdi, tdo_req);
/* check and process the input queue */ /* check and process the input queue */
if (bitq_interface->in_rdy()) bitq_in_proc(); if (bitq_interface->in_rdy()) bitq_in_proc();
} }
void bitq_end_state(enum tap_state state) void bitq_end_state(enum tap_state state)
{ {
if (state==-1) return; if (state==-1) return;
if (tap_move_map[state]==-1) { if (tap_move_map[state]==-1) {
ERROR("BUG: %i is not a valid end state", state); ERROR("BUG: %i is not a valid end state", state);
exit(-1); exit(-1);
} }
end_state = state; end_state = state;
} }
void bitq_state_move(enum tap_state new_state) void bitq_state_move(enum tap_state new_state)
{ {
int i=0; int i=0;
u8 tms_scan; u8 tms_scan;
if (tap_move_map[cur_state]==-1 || tap_move_map[new_state]==-1) { if (tap_move_map[cur_state]==-1 || tap_move_map[new_state]==-1) {
ERROR("TAP move from or to unstable state"); ERROR("TAP move from or to unstable state");
exit(-1); exit(-1);
} }
tms_scan=TAP_MOVE(cur_state, new_state); tms_scan=TAP_MOVE(cur_state, new_state);
for (i=0; i<7; i++) { for (i=0; i<7; i++) {
bitq_io(tms_scan&1, 0, 0); bitq_io(tms_scan&1, 0, 0);
tms_scan>>=1; tms_scan>>=1;
} }
cur_state = new_state; cur_state = new_state;
} }
void bitq_path_move(pathmove_command_t *cmd) void bitq_path_move(pathmove_command_t *cmd)
{ {
int i; int i;
for (i=0; i<=cmd->num_states; i++) { for (i=0; i<=cmd->num_states; i++) {
if (tap_transitions[cur_state].low == cmd->path[i]) bitq_io(0, 0, 0); if (tap_transitions[cur_state].low == cmd->path[i]) bitq_io(0, 0, 0);
else if (tap_transitions[cur_state].high == cmd->path[i]) bitq_io(1, 0, 0); else if (tap_transitions[cur_state].high == cmd->path[i]) bitq_io(1, 0, 0);
else { else {
ERROR("BUG: %s -> %s isn't a valid TAP transition", tap_state_strings[cur_state], tap_state_strings[cmd->path[i]]); ERROR("BUG: %s -> %s isn't a valid TAP transition", tap_state_strings[cur_state], tap_state_strings[cmd->path[i]]);
exit(-1); exit(-1);
} }
cur_state = cmd->path[i]; cur_state = cmd->path[i];
} }
end_state = cur_state; end_state = cur_state;
} }
void bitq_runtest(int num_cycles) void bitq_runtest(int num_cycles)
{ {
int i; int i;
/* only do a state_move when we're not already in RTI */ /* only do a state_move when we're not already in RTI */
if (cur_state != TAP_RTI) bitq_state_move(TAP_RTI); if (cur_state != TAP_RTI) bitq_state_move(TAP_RTI);
/* execute num_cycles */ /* execute num_cycles */
for (i = 0; i < num_cycles; i++) for (i = 0; i < num_cycles; i++)
bitq_io(0, 0, 0); bitq_io(0, 0, 0);
/* finish in end_state */ /* finish in end_state */
if (cur_state != end_state) bitq_state_move(end_state); if (cur_state != end_state) bitq_state_move(end_state);
} }
void bitq_scan_field(scan_field_t *field, int pause) void bitq_scan_field(scan_field_t *field, int pause)
{ {
int bit_cnt; int bit_cnt;
int tdo_req; int tdo_req;
u8 *out_ptr; u8 *out_ptr;
u8 out_mask; u8 out_mask;
if ( field->in_value || field->in_handler) tdo_req=1; if ( field->in_value || field->in_handler) tdo_req=1;
else tdo_req=0; else tdo_req=0;
if (field->out_value==NULL) { if (field->out_value==NULL) {
/* just send zeros and request data from TDO */ /* just send zeros and request data from TDO */
for (bit_cnt=field->num_bits; bit_cnt>1; bit_cnt--) for (bit_cnt=field->num_bits; bit_cnt>1; bit_cnt--)
bitq_io(0, 0, tdo_req); bitq_io(0, 0, tdo_req);
bitq_io(pause, 0, tdo_req); bitq_io(pause, 0, tdo_req);
} }
else { else {
/* send data, and optionally request TDO */ /* send data, and optionally request TDO */
out_mask=0x01; out_mask=0x01;
out_ptr=field->out_value; out_ptr=field->out_value;
for (bit_cnt=field->num_bits; bit_cnt>1; bit_cnt--) { for (bit_cnt=field->num_bits; bit_cnt>1; bit_cnt--) {
bitq_io(0, ((*out_ptr)&out_mask)!=0, tdo_req); bitq_io(0, ((*out_ptr)&out_mask)!=0, tdo_req);
if (out_mask==0x80) { if (out_mask==0x80) {
out_mask=0x01; out_mask=0x01;
out_ptr++; out_ptr++;
} }
else out_mask<<=1; else out_mask<<=1;
} }
bitq_io(pause, ((*out_ptr)&out_mask)!=0, tdo_req); bitq_io(pause, ((*out_ptr)&out_mask)!=0, tdo_req);
} }
if (pause) { if (pause) {
bitq_io(0,0,0); bitq_io(0,0,0);
if (cur_state==TAP_SI) cur_state=TAP_PI; if (cur_state==TAP_SI) cur_state=TAP_PI;
else if (cur_state==TAP_SD) cur_state=TAP_PD; else if (cur_state==TAP_SD) cur_state=TAP_PD;
} }
} }
void bitq_scan(scan_command_t *cmd) void bitq_scan(scan_command_t *cmd)
{ {
int i; int i;
if (cmd->ir_scan) bitq_state_move(TAP_SI); if (cmd->ir_scan) bitq_state_move(TAP_SI);
else bitq_state_move(TAP_SD); else bitq_state_move(TAP_SD);
for (i=0; i < cmd->num_fields-1; i++) for (i=0; i < cmd->num_fields-1; i++)
bitq_scan_field(&cmd->fields[i], 0); bitq_scan_field(&cmd->fields[i], 0);
bitq_scan_field(&cmd->fields[i], 1); bitq_scan_field(&cmd->fields[i], 1);
} }
int bitq_execute_queue(void) int bitq_execute_queue(void)
{ {
jtag_command_t *cmd = jtag_command_queue; /* currently processed command */ jtag_command_t *cmd = jtag_command_queue; /* currently processed command */
bitq_in_state.cmd = jtag_command_queue; bitq_in_state.cmd = jtag_command_queue;
bitq_in_state.field_idx = 0; bitq_in_state.field_idx = 0;
bitq_in_state.bit_pos = 0; bitq_in_state.bit_pos = 0;
bitq_in_state.status = ERROR_OK; bitq_in_state.status = ERROR_OK;
while (cmd) { while (cmd) {
switch (cmd->type) { switch (cmd->type) {
case JTAG_END_STATE: case JTAG_END_STATE:
#ifdef _DEBUG_JTAG_IO_ #ifdef _DEBUG_JTAG_IO_
DEBUG("end_state: %i", cmd->cmd.end_state->end_state); DEBUG("end_state: %i", cmd->cmd.end_state->end_state);
#endif #endif
bitq_end_state(cmd->cmd.end_state->end_state); bitq_end_state(cmd->cmd.end_state->end_state);
break; break;
case JTAG_RESET: case JTAG_RESET:
#ifdef _DEBUG_JTAG_IO_ #ifdef _DEBUG_JTAG_IO_
DEBUG("reset trst: %i srst %i", cmd->cmd.reset->trst, cmd->cmd.reset->srst); DEBUG("reset trst: %i srst %i", cmd->cmd.reset->trst, cmd->cmd.reset->srst);
#endif #endif
bitq_interface->reset(cmd->cmd.reset->trst, cmd->cmd.reset->srst); bitq_interface->reset(cmd->cmd.reset->trst, cmd->cmd.reset->srst);
if (bitq_interface->in_rdy()) bitq_in_proc(); if (bitq_interface->in_rdy()) bitq_in_proc();
break; break;
case JTAG_RUNTEST: case JTAG_RUNTEST:
#ifdef _DEBUG_JTAG_IO_ #ifdef _DEBUG_JTAG_IO_
DEBUG("runtest %i cycles, end in %i", cmd->cmd.runtest->num_cycles, cmd->cmd.runtest->end_state); DEBUG("runtest %i cycles, end in %i", cmd->cmd.runtest->num_cycles, cmd->cmd.runtest->end_state);
#endif #endif
bitq_end_state(cmd->cmd.runtest->end_state); bitq_end_state(cmd->cmd.runtest->end_state);
bitq_runtest(cmd->cmd.runtest->num_cycles); bitq_runtest(cmd->cmd.runtest->num_cycles);
break; break;
case JTAG_STATEMOVE: case JTAG_STATEMOVE:
#ifdef _DEBUG_JTAG_IO_ #ifdef _DEBUG_JTAG_IO_
DEBUG("statemove end in %i", cmd->cmd.statemove->end_state); DEBUG("statemove end in %i", cmd->cmd.statemove->end_state);
#endif #endif
bitq_end_state(cmd->cmd.statemove->end_state); bitq_end_state(cmd->cmd.statemove->end_state);
bitq_state_move(end_state); /* uncoditional TAP move */ bitq_state_move(end_state); /* uncoditional TAP move */
break; break;
case JTAG_PATHMOVE: case JTAG_PATHMOVE:
#ifdef _DEBUG_JTAG_IO_ #ifdef _DEBUG_JTAG_IO_
DEBUG("pathmove: %i states, end in %i", cmd->cmd.pathmove->num_states, cmd->cmd.pathmove->path[cmd->cmd.pathmove->num_states - 1]); DEBUG("pathmove: %i states, end in %i", cmd->cmd.pathmove->num_states, cmd->cmd.pathmove->path[cmd->cmd.pathmove->num_states - 1]);
#endif #endif
bitq_path_move(cmd->cmd.pathmove); bitq_path_move(cmd->cmd.pathmove);
break; break;
case JTAG_SCAN: case JTAG_SCAN:
#ifdef _DEBUG_JTAG_IO_ #ifdef _DEBUG_JTAG_IO_
DEBUG("scan end in %i", cmd->cmd.scan->end_state); DEBUG("scan end in %i", cmd->cmd.scan->end_state);
if (cmd->cmd.scan->ir_scan) DEBUG("scan ir"); if (cmd->cmd.scan->ir_scan) DEBUG("scan ir");
else DEBUG("scan dr"); else DEBUG("scan dr");
#endif #endif
bitq_end_state(cmd->cmd.scan->end_state); bitq_end_state(cmd->cmd.scan->end_state);
bitq_scan(cmd->cmd.scan); bitq_scan(cmd->cmd.scan);
if (cur_state != end_state) bitq_state_move(end_state); if (cur_state != end_state) bitq_state_move(end_state);
break; break;
case JTAG_SLEEP: case JTAG_SLEEP:
#ifdef _DEBUG_JTAG_IO_ #ifdef _DEBUG_JTAG_IO_
DEBUG("sleep %i", cmd->cmd.sleep->us); DEBUG("sleep %i", cmd->cmd.sleep->us);
#endif #endif
bitq_interface->sleep(cmd->cmd.sleep->us); bitq_interface->sleep(cmd->cmd.sleep->us);
if (bitq_interface->in_rdy()) bitq_in_proc(); if (bitq_interface->in_rdy()) bitq_in_proc();
break; break;
default: default:
ERROR("BUG: unknown JTAG command type encountered"); ERROR("BUG: unknown JTAG command type encountered");
exit(-1); exit(-1);
} }
cmd = cmd->next; cmd = cmd->next;
} }
bitq_interface->flush(); bitq_interface->flush();
bitq_in_proc(); bitq_in_proc();
if (bitq_in_state.cmd) { if (bitq_in_state.cmd) {
ERROR("missing data from bitq interface"); ERROR("missing data from bitq interface");
return ERROR_JTAG_QUEUE_FAILED; return ERROR_JTAG_QUEUE_FAILED;
} }
if (bitq_interface->in()>=0) { if (bitq_interface->in()>=0) {
ERROR("extra data from bitq interface"); ERROR("extra data from bitq interface");
return ERROR_JTAG_QUEUE_FAILED; return ERROR_JTAG_QUEUE_FAILED;
} }
return bitq_in_state.status; return bitq_in_state.status;
} }
void bitq_cleanup(void) void bitq_cleanup(void)
{ {
if (bitq_in_buffer!=NULL) if (bitq_in_buffer!=NULL)
{ {
free(bitq_in_buffer); free(bitq_in_buffer);
bitq_in_buffer=NULL; bitq_in_buffer=NULL;
} }
} }

1363
src/jtag/usbprog.c
View File

File diff suppressed because it is too large Load Diff