-/***************************************************************************\r
- * Copyright (C) 2007-2008 by Øyvind Harboe *\r
- * *\r
- * This program is free software; you can redistribute it and/or modify *\r
- * it under the terms of the GNU General Public License as published by *\r
- * the Free Software Foundation; either version 2 of the License, or *\r
- * (at your option) any later version. *\r
- * *\r
- * This program is distributed in the hope that it will be useful, *\r
- * but WITHOUT ANY WARRANTY; without even the implied warranty of *\r
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *\r
- * GNU General Public License for more details. *\r
- * *\r
- * You should have received a copy of the GNU General Public License *\r
- * along with this program; if not, write to the *\r
- * Free Software Foundation, Inc., *\r
- * 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. *\r
- ***************************************************************************/\r
-#ifdef HAVE_CONFIG_H\r
-#include "config.h"\r
-#endif\r
-\r
-\r
-#include "log.h"\r
-#include "jtag.h"\r
-#include "bitbang.h"\r
-#include "../target/embeddedice.h"\r
-\r
-\r
-#include <cyg/hal/hal_io.h> // low level i/o\r
-#include <cyg/hal/var_io.h> // common registers\r
-#include <cyg/hal/plf_io.h> // platform registers\r
-#include <cyg/hal/hal_diag.h>\r
-\r
-#include <stdlib.h>\r
-\r
-\r
-extern int jtag_error;\r
-\r
-/* low level command set\r
- */\r
-int eCosBoard_read(void);\r
-static void eCosBoard_write(int tck, int tms, int tdi);\r
-void eCosBoard_reset(int trst, int srst);\r
-\r
-\r
-int eCosBoard_speed(int speed);\r
-int eCosBoard_register_commands(struct command_context_s *cmd_ctx);\r
-int eCosBoard_init(void);\r
-int eCosBoard_quit(void);\r
-\r
-/* interface commands */\r
-int eCosBoard_handle_eCosBoard_port_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);\r
-\r
-static int eCosBoard_khz(int khz, int *jtag_speed)\r
-{\r
- if (khz==0)\r
- {\r
- *jtag_speed=0;\r
- }\r
- else\r
- {\r
- *jtag_speed=64000/khz;\r
- }\r
- return ERROR_OK;\r
-}\r
-\r
-static int eCosBoard_speed_div(int speed, int *khz)\r
-{\r
- if (speed==0)\r
- {\r
- *khz = 0;\r
- }\r
- else\r
- {\r
- *khz=64000/speed;\r
- }\r
-\r
- return ERROR_OK;\r
-}\r
-\r
-\r
-jtag_interface_t eCosBoard_interface =\r
-{\r
- .name = "ZY1000",\r
- .execute_queue = bitbang_execute_queue,\r
- .speed = eCosBoard_speed,\r
- .register_commands = eCosBoard_register_commands,\r
- .init = eCosBoard_init,\r
- .quit = eCosBoard_quit,\r
- .khz = eCosBoard_khz,\r
- .speed_div = eCosBoard_speed_div,\r
-};\r
-\r
-bitbang_interface_t eCosBoard_bitbang =\r
-{\r
- .read = eCosBoard_read,\r
- .write = eCosBoard_write,\r
- .reset = eCosBoard_reset\r
-};\r
-\r
-\r
-\r
-static void eCosBoard_write(int tck, int tms, int tdi)\r
-{\r
-\r
-}\r
-\r
-int eCosBoard_read(void)\r
-{\r
- return -1;\r
-}\r
-\r
-extern bool readSRST();\r
-\r
-void eCosBoard_reset(int trst, int srst)\r
-{\r
- LOG_DEBUG("zy1000 trst=%d, srst=%d", trst, srst);\r
- if(!srst)\r
- {\r
- ZY1000_POKE(0x08000014, 0x00000001);\r
- }\r
- else\r
- {\r
- /* Danger!!! if clk!=0 when in\r
- * idle in TAP_RTI, reset halt on str912 will fail.\r
- */\r
- ZY1000_POKE(0x08000010, 0x00000001);\r
- }\r
-\r
- if(!trst)\r
- {\r
- ZY1000_POKE(0x08000014, 0x00000002);\r
- }\r
- else\r
- {\r
- /* assert reset */\r
- ZY1000_POKE(0x08000010, 0x00000002);\r
- }\r
- \r
- if (trst||(srst&&(jtag_reset_config & RESET_SRST_PULLS_TRST)))\r
- {\r
- waitIdle();\r
- /* we're now in the TLR state until trst is deasserted */\r
- ZY1000_POKE(0x08000020, TAP_TLR);\r
- } else\r
- {\r
- /* We'll get RCLK failure when we assert TRST, so clear any false positives here */\r
- ZY1000_POKE(0x08000014, 0x400); \r
- }\r
-\r
- /* wait for srst to float back up */\r
- if (!srst)\r
- {\r
- int i;\r
- for (i=0; i<1000; i++)\r
- {\r
- // We don't want to sense our own reset, so we clear here.\r
- // There is of course a timing hole where we could loose\r
- // a "real" reset.\r
- if (!readSRST())\r
- break;\r
-\r
- /* wait 1ms */\r
- alive_sleep(1);\r
- }\r
-\r
- if (i==1000)\r
- {\r
- LOG_USER("SRST didn't deassert after %dms", i);\r
- } else if (i>1)\r
- {\r
- LOG_USER("SRST took %dms to deassert", i);\r
- }\r
- }\r
-}\r
-\r
-int eCosBoard_speed(int speed)\r
-{\r
- if(speed == 0)\r
- {\r
- /*0 means RCLK*/\r
- speed = 0;\r
- ZY1000_POKE(0x08000010, 0x100);\r
- LOG_DEBUG("jtag_speed using RCLK");\r
- }\r
- else\r
- {\r
- if(speed > 8190 || speed < 2)\r
- {\r
- LOG_ERROR("valid ZY1000 jtag_speed=[8190,2]. Divisor is 64MHz / even values between 8190-2, i.e. min 7814Hz, max 32MHz");\r
- return ERROR_INVALID_ARGUMENTS;\r
- }\r
-\r
- LOG_USER("jtag_speed %d => JTAG clk=%f", speed, 64.0/(float)speed);\r
- ZY1000_POKE(0x08000014, 0x100);\r
- ZY1000_POKE(0x0800001c, speed&~1);\r
- }\r
- return ERROR_OK;\r
-}\r
-\r
-int eCosBoard_register_commands(struct command_context_s *cmd_ctx)\r
-{\r
- return ERROR_OK;\r
-}\r
-\r
-\r
-int eCosBoard_init(void)\r
-{\r
- ZY1000_POKE(0x08000010, 0x30); // Turn on LED1 & LED2\r
-\r
- /* deassert resets. Important to avoid infinite loop waiting for SRST to deassert */\r
- eCosBoard_reset(0, 0);\r
- eCosBoard_speed(jtag_speed);\r
-\r
- bitbang_interface = &eCosBoard_bitbang;\r
-\r
- return ERROR_OK;\r
-}\r
-\r
-int eCosBoard_quit(void)\r
-{\r
-\r
- return ERROR_OK;\r
-}\r
-\r
-\r
-\r
-/* loads a file and returns a pointer to it in memory. The file contains\r
- * a 0 byte(sentinel) after len bytes - the length of the file. */\r
-int loadFile(const char *fileName, void **data, int *len)\r
-{\r
- FILE * pFile;\r
- pFile = fopen (fileName,"rb");\r
- if (pFile==NULL)\r
- {\r
- LOG_ERROR("Can't open %s\n", fileName);\r
- return ERROR_JTAG_DEVICE_ERROR;\r
- }\r
- if (fseek (pFile, 0, SEEK_END)!=0)\r
- {\r
- LOG_ERROR("Can't open %s\n", fileName);\r
- fclose(pFile);\r
- return ERROR_JTAG_DEVICE_ERROR;\r
- }\r
- *len=ftell (pFile);\r
- if (*len==-1)\r
- {\r
- LOG_ERROR("Can't open %s\n", fileName);\r
- fclose(pFile);\r
- return ERROR_JTAG_DEVICE_ERROR;\r
- }\r
-\r
- if (fseek (pFile, 0, SEEK_SET)!=0)\r
- {\r
- LOG_ERROR("Can't open %s\n", fileName);\r
- fclose(pFile);\r
- return ERROR_JTAG_DEVICE_ERROR;\r
- }\r
- *data=malloc(*len+1);\r
- if (*data==NULL)\r
- {\r
- LOG_ERROR("Can't open %s\n", fileName);\r
- fclose(pFile);\r
- return ERROR_JTAG_DEVICE_ERROR;\r
- }\r
-\r
- if (fread(*data, 1, *len, pFile)!=*len)\r
- {\r
- fclose(pFile);\r
- free(*data);\r
- LOG_ERROR("Can't open %s\n", fileName);\r
- return ERROR_JTAG_DEVICE_ERROR;\r
- }\r
- fclose (pFile);\r
- *(((char *)(*data))+*len)=0; /* sentinel */\r
-\r
- return ERROR_OK;\r
-\r
-\r
-\r
-}\r
-\r
-\r
-\r
-\r
-int interface_jtag_execute_queue(void)\r
-{\r
- cyg_uint32 empty;\r
-\r
- waitIdle();\r
- ZY1000_PEEK(0x08000010, empty);\r
- /* clear JTAG error register */\r
- ZY1000_POKE(0x08000014, 0x400);\r
-\r
- if ((empty&0x400)!=0)\r
- {\r
- LOG_WARNING("RCLK timeout");\r
- /* the error is informative only as we don't want to break the firmware if there\r
- * is a false positive.\r
- */\r
-// return ERROR_FAIL;\r
- }\r
- return ERROR_OK;\r
-}\r
-\r
-\r
-\r
-\r
-\r
-static cyg_uint32 getShiftValue()\r
-{\r
- cyg_uint32 value;\r
- waitIdle();\r
- ZY1000_PEEK(0x0800000c, value);\r
- VERBOSE(LOG_INFO("getShiftValue %08x", value));\r
- return value;\r
-}\r
-#if 0\r
-static cyg_uint32 getShiftValueFlip()\r
-{\r
- cyg_uint32 value;\r
- waitIdle();\r
- ZY1000_PEEK(0x08000018, value);\r
- VERBOSE(LOG_INFO("getShiftValue %08x (flipped)", value));\r
- return value;\r
-}\r
-#endif\r
-\r
-#if 0\r
-static void shiftValueInnerFlip(const enum tap_state state, const enum tap_state endState, int repeat, cyg_uint32 value)\r
-{\r
- VERBOSE(LOG_INFO("shiftValueInner %s %s %d %08x (flipped)", tap_state_strings[state], tap_state_strings[endState], repeat, value));\r
- cyg_uint32 a,b;\r
- a=state;\r
- b=endState;\r
- ZY1000_POKE(0x0800000c, value);\r
- ZY1000_POKE(0x08000008, (1<<15)|(repeat<<8)|(a<<4)|b);\r
- VERBOSE(getShiftValueFlip());\r
-}\r
-#endif\r
-\r
-extern int jtag_check_value(u8 *captured, void *priv);\r
-\r
-static void gotoEndState()\r
-{\r
- setCurrentState(cmd_queue_end_state);\r
-}\r
-\r
-static __inline void scanFields(int num_fields, scan_field_t *fields, enum tap_state shiftState, int pause)\r
-{\r
- int i;\r
- int j;\r
- int k;\r
-\r
- for (i = 0; i < num_fields; i++)\r
- {\r
- cyg_uint32 value;\r
-\r
- static u8 *in_buff=NULL; /* pointer to buffer for scanned data */\r
- static int in_buff_size=0;\r
- u8 *inBuffer=NULL;\r
-\r
-\r
- // figure out where to store the input data\r
- int num_bits=fields[i].num_bits;\r
- if (fields[i].in_value!=NULL)\r
- {\r
- inBuffer=fields[i].in_value;\r
- } else if (fields[i].in_handler!=NULL)\r
- {\r
- if (in_buff_size*8<num_bits)\r
- {\r
- // we need more space\r
- if (in_buff!=NULL)\r
- free(in_buff);\r
- in_buff=NULL;\r
- in_buff_size=(num_bits+7)/8;\r
- in_buff=malloc(in_buff_size);\r
- if (in_buff==NULL)\r
- {\r
- LOG_ERROR("Out of memory");\r
- jtag_error=ERROR_JTAG_QUEUE_FAILED;\r
- return;\r
- }\r
- }\r
- inBuffer=in_buff;\r
- }\r
-\r
- // here we shuffle N bits out/in\r
- j=0;\r
- while (j<num_bits)\r
- {\r
- enum tap_state pause_state;\r
- int l;\r
- k=num_bits-j;\r
- pause_state=(shiftState==TAP_SD)?TAP_SD:TAP_SI;\r
- if (k>32)\r
- {\r
- k=32;\r
- /* we have more to shift out */\r
- } else if (pause&&(i == num_fields-1))\r
- {\r
- /* this was the last to shift out this time */\r
- pause_state=(shiftState==TAP_SD)?TAP_PD:TAP_PI;\r
- }\r
-\r
- // we have (num_bits+7)/8 bytes of bits to toggle out.\r
- // bits are pushed out LSB to MSB\r
- value=0;\r
- if (fields[i].out_value!=NULL)\r
- {\r
- for (l=0; l<k; l+=8)\r
- {\r
- value|=fields[i].out_value[(j+l)/8]<<l;\r
- }\r
- }\r
- /* mask away unused bits for easier debugging */\r
- value&=~(((u32)0xffffffff)<<k);\r
-\r
- shiftValueInner(shiftState, pause_state, k, value);\r
-\r
- if (inBuffer!=NULL)\r
- {\r
- // data in, LSB to MSB\r
- value=getShiftValue();\r
- // we're shifting in data to MSB, shift data to be aligned for returning the value\r
- value >>= 32-k;\r
-\r
- for (l=0; l<k; l+=8)\r
- {\r
- inBuffer[(j+l)/8]=(value>>l)&0xff;\r
- }\r
- }\r
- j+=k;\r
- }\r
-\r
- if (fields[i].in_handler!=NULL)\r
- {\r
- // invoke callback\r
- int r=fields[i].in_handler(inBuffer, fields[i].in_handler_priv, fields+i);\r
- if (r!=ERROR_OK)\r
- {\r
- /* this will cause jtag_execute_queue() to return an error */\r
- jtag_error=r;\r
- }\r
- }\r
- }\r
-}\r
-\r
-int interface_jtag_add_end_state(enum tap_state state)\r
-{\r
- return ERROR_OK;\r
-}\r
-\r
-\r
-int interface_jtag_add_ir_scan(int num_fields, scan_field_t *fields, enum tap_state state)\r
-{\r
-\r
- int i, j;\r
- int scan_size = 0;\r
- jtag_device_t *device;\r
-\r
- for (i=0; i < jtag_num_devices; i++)\r
- {\r
- int pause=i==(jtag_num_devices-1);\r
- int found = 0;\r
- device = jtag_get_device(i);\r
- scan_size = device->ir_length;\r
-\r
- /* search the list */\r
- for (j=0; j < num_fields; j++)\r
- {\r
- if (i == fields[j].device)\r
- {\r
- found = 1;\r
-\r
- if ((jtag_verify_capture_ir)&&(fields[j].in_handler==NULL))\r
- {\r
- jtag_set_check_value(fields+j, device->expected, device->expected_mask, NULL);\r
- } else if (jtag_verify_capture_ir)\r
- {\r
- fields[j].in_check_value = device->expected;\r
- fields[j].in_check_mask = device->expected_mask;\r
- }\r
-\r
- scanFields(1, fields+j, TAP_SI, pause);\r
- /* update device information */\r
- buf_cpy(fields[j].out_value, jtag_get_device(i)->cur_instr, scan_size);\r
-\r
- device->bypass = 0;\r
- break;\r
- }\r
- }\r
-\r
- if (!found)\r
- {\r
- /* if a device isn't listed, set it to BYPASS */\r
- u8 ones[]={0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff};\r
-\r
- scan_field_t tmp;\r
- memset(&tmp, 0, sizeof(tmp));\r
- tmp.out_value = ones;\r
- tmp.num_bits = scan_size;\r
- scanFields(1, &tmp, TAP_SI, pause);\r
- /* update device information */\r
- buf_cpy(tmp.out_value, jtag_get_device(i)->cur_instr, scan_size);\r
- device->bypass = 1;\r
- }\r
- }\r
- gotoEndState();\r
-\r
- return ERROR_OK;\r
-}\r
-\r
-\r
-\r
-\r
-\r
-int interface_jtag_add_plain_ir_scan(int num_fields, scan_field_t *fields, enum tap_state state)\r
-{\r
- scanFields(num_fields, fields, TAP_SI, 1);\r
- gotoEndState();\r
-\r
- return ERROR_OK;\r
-}\r
-\r
-/*extern jtag_command_t **jtag_get_last_command_p(void);*/\r
-\r
-int interface_jtag_add_dr_scan(int num_fields, scan_field_t *fields, enum tap_state state)\r
-{\r
- int i, j;\r
- for (i=0; i < jtag_num_devices; i++)\r
- {\r
- int found = 0;\r
- int pause = (i==(jtag_num_devices-1));\r
-\r
- for (j=0; j < num_fields; j++)\r
- {\r
- if (i == fields[j].device)\r
- {\r
- found = 1;\r
-\r
- scanFields(1, fields+j, TAP_SD, pause);\r
- }\r
- }\r
- if (!found)\r
- {\r
-#ifdef _DEBUG_JTAG_IO_\r
- /* if a device isn't listed, the BYPASS register should be selected */\r
- if (!jtag_get_device(i)->bypass)\r
- {\r
- LOG_ERROR("BUG: no scan data for a device not in BYPASS");\r
- exit(-1);\r
- }\r
-#endif\r
-\r
- scan_field_t tmp;\r
- /* program the scan field to 1 bit length, and ignore it's value */\r
- tmp.num_bits = 1;\r
- tmp.out_value = NULL;\r
- tmp.out_mask = NULL;\r
- tmp.in_value = NULL;\r
- tmp.in_check_value = NULL;\r
- tmp.in_check_mask = NULL;\r
- tmp.in_handler = NULL;\r
- tmp.in_handler_priv = NULL;\r
-\r
- scanFields(1, &tmp, TAP_SD, pause);\r
- }\r
- else\r
- {\r
-#ifdef _DEBUG_JTAG_IO_\r
- /* if a device is listed, the BYPASS register must not be selected */\r
- if (jtag_get_device(i)->bypass)\r
- {\r
- LOG_WARNING("scan data for a device in BYPASS");\r
- }\r
-#endif\r
- }\r
- }\r
- gotoEndState();\r
- return ERROR_OK;\r
-}\r
-\r
-int interface_jtag_add_plain_dr_scan(int num_fields, scan_field_t *fields, enum tap_state state)\r
-{\r
- scanFields(num_fields, fields, TAP_SD, 1);\r
- gotoEndState();\r
- return ERROR_OK;\r
-}\r
-\r
-\r
-int interface_jtag_add_tlr()\r
-{\r
- setCurrentState(TAP_TLR);\r
- return ERROR_OK;\r
-}\r
-\r
-\r
-\r
-\r
-extern int jtag_nsrst_delay;\r
-extern int jtag_ntrst_delay;\r
-\r
-int interface_jtag_add_reset(int req_trst, int req_srst)\r
-{\r
- eCosBoard_reset(req_trst, req_srst);\r
- return ERROR_OK;\r
-}\r
-\r
-int interface_jtag_add_runtest(int num_cycles, enum tap_state state)\r
-{\r
- /* num_cycles can be 0 */\r
- setCurrentState(TAP_RTI);\r
-\r
- /* execute num_cycles, 32 at the time. */\r
- int i;\r
- for (i=0; i<num_cycles; i+=32)\r
- {\r
- int num;\r
- num=32;\r
- if (num_cycles-i<num)\r
- {\r
- num=num_cycles-i;\r
- }\r
- shiftValueInner(TAP_RTI, TAP_RTI, num, 0);\r
- }\r
-\r
-#if !TEST_MANUAL()\r
- /* finish in end_state */\r
- setCurrentState(state);\r
-#else\r
- enum tap_state t=TAP_RTI;\r
- /* test manual drive code on any target */\r
- int tms;\r
- u8 tms_scan = TAP_MOVE(t, state);\r
- \r
- for (i = 0; i < 7; i++)\r
- {\r
- tms = (tms_scan >> i) & 1;\r
- waitIdle();\r
- ZY1000_POKE(0x08000028, tms);\r
- }\r
- waitIdle();\r
- ZY1000_POKE(0x08000020, state); \r
-#endif\r
-\r
-\r
- return ERROR_OK;\r
-}\r
-\r
-int interface_jtag_add_sleep(u32 us)\r
-{\r
- jtag_sleep(us);\r
- return ERROR_OK;\r
-}\r
-\r
-int interface_jtag_add_pathmove(int num_states, enum tap_state *path)\r
-{\r
- int state_count;\r
- int tms = 0;\r
-\r
- /*wait for the fifo to be empty*/\r
- waitIdle();\r
-\r
- state_count = 0;\r
-\r
- enum tap_state cur_state=cmd_queue_cur_state;\r
-\r
- while (num_states)\r
- {\r
- if (tap_transitions[cur_state].low == path[state_count])\r
- {\r
- tms = 0;\r
- }\r
- else if (tap_transitions[cur_state].high == path[state_count])\r
- {\r
- tms = 1;\r
- }\r
- else\r
- {\r
- LOG_ERROR("BUG: %s -> %s isn't a valid TAP transition", tap_state_strings[cur_state], tap_state_strings[path[state_count]]);\r
- exit(-1);\r
- }\r
-\r
- waitIdle();\r
- ZY1000_POKE(0x08000028, tms);\r
-\r
- cur_state = path[state_count];\r
- state_count++;\r
- num_states--;\r
- }\r
-\r
- waitIdle();\r
- ZY1000_POKE(0x08000020, cur_state);\r
- return ERROR_OK;\r
-}\r
-\r
-\r
-\r
-void embeddedice_write_dcc(int chain_pos, int reg_addr, u8 *buffer, int little, int count)\r
-{\r
-// static int const reg_addr=0x5;\r
- enum tap_state end_state=cmd_queue_end_state;\r
- if (jtag_num_devices==1)\r
- {\r
- /* better performance via code duplication */\r
- if (little)\r
- {\r
- int i;\r
- for (i = 0; i < count; i++)\r
- {\r
- shiftValueInner(TAP_SD, TAP_SD, 32, fast_target_buffer_get_u32(buffer, 1));\r
- shiftValueInner(TAP_SD, end_state, 6, reg_addr|(1<<5));\r
- buffer+=4;\r
- }\r
- } else\r
- {\r
- int i;\r
- for (i = 0; i < count; i++)\r
- {\r
- shiftValueInner(TAP_SD, TAP_SD, 32, fast_target_buffer_get_u32(buffer, 0));\r
- shiftValueInner(TAP_SD, end_state, 6, reg_addr|(1<<5));\r
- buffer+=4;\r
- }\r
- }\r
- }\r
- else\r
- {\r
- int i;\r
- for (i = 0; i < count; i++)\r
- {\r
- embeddedice_write_reg_inner(chain_pos, reg_addr, fast_target_buffer_get_u32(buffer, little));\r
- buffer += 4;\r
- }\r
- }\r
-}\r
-\r
+/***************************************************************************
+ * Copyright (C) 2007-2008 by Øyvind Harboe *
+ * *
+ * This program is free software; you can redistribute it and/or modify *
+ * it under the terms of the GNU General Public License as published by *
+ * the Free Software Foundation; either version 2 of the License, or *
+ * (at your option) any later version. *
+ * *
+ * This program is distributed in the hope that it will be useful, *
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of *
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
+ * GNU General Public License for more details. *
+ * *
+ * You should have received a copy of the GNU General Public License *
+ * along with this program; if not, write to the *
+ * Free Software Foundation, Inc., *
+ * 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. *
+ ***************************************************************************/
+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#endif
+
+#define INCLUDE_JTAG_INTERFACE_H
+#include "embeddedice.h"
+#include "minidriver.h"
+#include "bitbang.h"
+
+#include <cyg/hal/hal_io.h> // low level i/o
+#include <cyg/hal/hal_diag.h>
+
+
+#define ZYLIN_VERSION "1.52"
+#define ZYLIN_DATE __DATE__
+#define ZYLIN_TIME __TIME__
+#define ZYLIN_OPENOCD "$Revision$"
+#define ZYLIN_OPENOCD_VERSION "Zylin JTAG ZY1000 " ZYLIN_VERSION " " ZYLIN_DATE " " ZYLIN_TIME
+const char *zylin_config_dir="/config/settings";
+
+/* low level command set
+ */
+int zy1000_read(void);
+static void zy1000_write(int tck, int tms, int tdi);
+void zy1000_reset(int trst, int srst);
+
+
+int zy1000_speed(int speed);
+int zy1000_register_commands(struct command_context_s *cmd_ctx);
+int zy1000_init(void);
+int zy1000_quit(void);
+
+/* interface commands */
+int zy1000_handle_zy1000_port_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
+
+static int zy1000_khz(int khz, int *jtag_speed)
+{
+ if (khz==0)
+ {
+ *jtag_speed=0;
+ }
+ else
+ {
+ *jtag_speed=64000/khz;
+ }
+ return ERROR_OK;
+}
+
+static int zy1000_speed_div(int speed, int *khz)
+{
+ if (speed==0)
+ {
+ *khz = 0;
+ }
+ else
+ {
+ *khz=64000/speed;
+ }
+
+ return ERROR_OK;
+}
+
+static bool readPowerDropout(void)
+{
+ cyg_uint32 state;
+ // sample and clear power dropout
+ HAL_WRITE_UINT32(ZY1000_JTAG_BASE+0x10, 0x80);
+ HAL_READ_UINT32(ZY1000_JTAG_BASE+0x10, state);
+ bool powerDropout;
+ powerDropout = (state & 0x80) != 0;
+ return powerDropout;
+}
+
+
+static bool readSRST(void)
+{
+ cyg_uint32 state;
+ // sample and clear SRST sensing
+ HAL_WRITE_UINT32(ZY1000_JTAG_BASE+0x10, 0x00000040);
+ HAL_READ_UINT32(ZY1000_JTAG_BASE+0x10, state);
+ bool srstAsserted;
+ srstAsserted = (state & 0x40) != 0;
+ return srstAsserted;
+}
+
+static int zy1000_srst_asserted(int *srst_asserted)
+{
+ *srst_asserted=readSRST();
+ return ERROR_OK;
+}
+
+static int zy1000_power_dropout(int *dropout)
+{
+ *dropout=readPowerDropout();
+ return ERROR_OK;
+}
+
+
+jtag_interface_t zy1000_interface =
+{
+ .name = "ZY1000",
+ .execute_queue = bitbang_execute_queue,
+ .speed = zy1000_speed,
+ .register_commands = zy1000_register_commands,
+ .init = zy1000_init,
+ .quit = zy1000_quit,
+ .khz = zy1000_khz,
+ .speed_div = zy1000_speed_div,
+ .power_dropout = zy1000_power_dropout,
+ .srst_asserted = zy1000_srst_asserted,
+};
+
+bitbang_interface_t zy1000_bitbang =
+{
+ .read = zy1000_read,
+ .write = zy1000_write,
+ .reset = zy1000_reset
+};
+
+
+
+static void zy1000_write(int tck, int tms, int tdi)
+{
+
+}
+
+int zy1000_read(void)
+{
+ return -1;
+}
+
+extern bool readSRST(void);
+
+void zy1000_reset(int trst, int srst)
+{
+ LOG_DEBUG("zy1000 trst=%d, srst=%d", trst, srst);
+ if(!srst)
+ {
+ ZY1000_POKE(ZY1000_JTAG_BASE+0x14, 0x00000001);
+ }
+ else
+ {
+ /* Danger!!! if clk!=0 when in
+ * idle in TAP_IDLE, reset halt on str912 will fail.
+ */
+ ZY1000_POKE(ZY1000_JTAG_BASE+0x10, 0x00000001);
+ }
+
+ if(!trst)
+ {
+ ZY1000_POKE(ZY1000_JTAG_BASE+0x14, 0x00000002);
+ }
+ else
+ {
+ /* assert reset */
+ ZY1000_POKE(ZY1000_JTAG_BASE+0x10, 0x00000002);
+ }
+
+ if (trst||(srst&&(jtag_reset_config & RESET_SRST_PULLS_TRST)))
+ {
+ waitIdle();
+ /* we're now in the RESET state until trst is deasserted */
+ ZY1000_POKE(ZY1000_JTAG_BASE+0x20, TAP_RESET);
+ } else
+ {
+ /* We'll get RCLK failure when we assert TRST, so clear any false positives here */
+ ZY1000_POKE(ZY1000_JTAG_BASE+0x14, 0x400);
+ }
+
+ /* wait for srst to float back up */
+ if (!srst)
+ {
+ int i;
+ for (i=0; i<1000; i++)
+ {
+ // We don't want to sense our own reset, so we clear here.
+ // There is of course a timing hole where we could loose
+ // a "real" reset.
+ if (!readSRST())
+ break;
+
+ /* wait 1ms */
+ alive_sleep(1);
+ }
+
+ if (i==1000)
+ {
+ LOG_USER("SRST didn't deassert after %dms", i);
+ } else if (i>1)
+ {
+ LOG_USER("SRST took %dms to deassert", i);
+ }
+ }
+}
+
+int zy1000_speed(int speed)
+{
+ if(speed == 0)
+ {
+ /*0 means RCLK*/
+ speed = 0;
+ ZY1000_POKE(ZY1000_JTAG_BASE+0x10, 0x100);
+ LOG_DEBUG("jtag_speed using RCLK");
+ }
+ else
+ {
+ if(speed > 8190 || speed < 2)
+ {
+ LOG_USER("valid ZY1000 jtag_speed=[8190,2]. Divisor is 64MHz / even values between 8190-2, i.e. min 7814Hz, max 32MHz");
+ return ERROR_INVALID_ARGUMENTS;
+ }
+
+ LOG_USER("jtag_speed %d => JTAG clk=%f", speed, 64.0/(float)speed);
+ ZY1000_POKE(ZY1000_JTAG_BASE+0x14, 0x100);
+ ZY1000_POKE(ZY1000_JTAG_BASE+0x1c, speed&~1);
+ }
+ return ERROR_OK;
+}
+
+static bool savePower;
+
+
+static void setPower(bool power)
+{
+ savePower = power;
+ if (power)
+ {
+ HAL_WRITE_UINT32(ZY1000_JTAG_BASE+0x14, 0x8);
+ } else
+ {
+ HAL_WRITE_UINT32(ZY1000_JTAG_BASE+0x10, 0x8);
+ }
+}
+
+int handle_power_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
+{
+ if (argc > 1)
+ {
+ return ERROR_INVALID_ARGUMENTS;
+ }
+
+ if (argc == 1)
+ {
+ if (strcmp(args[0], "on") == 0)
+ {
+ setPower(1);
+ }
+ else if (strcmp(args[0], "off") == 0)
+ {
+ setPower(0);
+ } else
+ {
+ command_print(cmd_ctx, "arg is \"on\" or \"off\"");
+ return ERROR_INVALID_ARGUMENTS;
+ }
+ }
+
+ command_print(cmd_ctx, "Target power %s", savePower ? "on" : "off");
+
+ return ERROR_OK;
+}
+
+
+/* Give TELNET a way to find out what version this is */
+static int jim_zy1000_version(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
+{
+ if ((argc < 1) || (argc > 2))
+ return JIM_ERR;
+ char buff[128];
+ const char *version_str=NULL;
+
+ if (argc == 1)
+ {
+ version_str=ZYLIN_OPENOCD_VERSION;
+ } else
+ {
+ const char *str = Jim_GetString(argv[1], NULL);
+ if (strcmp("openocd", str) == 0)
+ {
+ int revision;
+ revision = atol(ZYLIN_OPENOCD+strlen("XRevision: "));
+ sprintf(buff, "%d", revision);
+ version_str=buff;
+ }
+ else if (strcmp("zy1000", str) == 0)
+ {
+ version_str=ZYLIN_VERSION;
+ }
+ else if (strcmp("date", str) == 0)
+ {
+ version_str=ZYLIN_DATE;
+ }
+ else
+ {
+ return JIM_ERR;
+ }
+ }
+
+ Jim_SetResult(interp, Jim_NewStringObj(interp, version_str, -1));
+
+ return JIM_OK;
+}
+
+
+static int
+zylinjtag_Jim_Command_powerstatus(Jim_Interp *interp,
+ int argc,
+ Jim_Obj * const *argv)
+{
+ if (argc != 1)
+ {
+ Jim_WrongNumArgs(interp, 1, argv, "powerstatus");
+ return JIM_ERR;
+ }
+
+ cyg_uint32 status;
+ ZY1000_PEEK(ZY1000_JTAG_BASE+0x10, status);
+
+ Jim_SetResult(interp, Jim_NewIntObj(interp, (status&0x80)!=0));
+
+ return JIM_OK;
+}
+
+int zy1000_register_commands(struct command_context_s *cmd_ctx)
+{
+ register_command(cmd_ctx, NULL, "power", handle_power_command, COMMAND_ANY,
+ "power <on/off> - turn power switch to target on/off. No arguments - print status.");
+
+ Jim_CreateCommand(interp, "zy1000_version", jim_zy1000_version, NULL, NULL);
+
+
+ Jim_CreateCommand(interp, "powerstatus", zylinjtag_Jim_Command_powerstatus, NULL, NULL);
+
+ return ERROR_OK;
+}
+
+
+
+
+int zy1000_init(void)
+{
+ LOG_USER("%s", ZYLIN_OPENOCD_VERSION);
+
+ ZY1000_POKE(ZY1000_JTAG_BASE+0x10, 0x30); // Turn on LED1 & LED2
+
+ setPower(true); // on by default
+
+
+ /* deassert resets. Important to avoid infinite loop waiting for SRST to deassert */
+ zy1000_reset(0, 0);
+ zy1000_speed(jtag_speed);
+
+ bitbang_interface = &zy1000_bitbang;
+
+ return ERROR_OK;
+}
+
+int zy1000_quit(void)
+{
+
+ return ERROR_OK;
+}
+
+
+
+int interface_jtag_execute_queue(void)
+{
+ cyg_uint32 empty;
+
+ waitIdle();
+ ZY1000_PEEK(ZY1000_JTAG_BASE+0x10, empty);
+ /* clear JTAG error register */
+ ZY1000_POKE(ZY1000_JTAG_BASE+0x14, 0x400);
+
+ if ((empty&0x400)!=0)
+ {
+ LOG_WARNING("RCLK timeout");
+ /* the error is informative only as we don't want to break the firmware if there
+ * is a false positive.
+ */
+// return ERROR_FAIL;
+ }
+ return ERROR_OK;
+}
+
+
+
+
+
+static cyg_uint32 getShiftValue(void)
+{
+ cyg_uint32 value;
+ waitIdle();
+ ZY1000_PEEK(ZY1000_JTAG_BASE+0xc, value);
+ VERBOSE(LOG_INFO("getShiftValue %08x", value));
+ return value;
+}
+#if 0
+static cyg_uint32 getShiftValueFlip(void)
+{
+ cyg_uint32 value;
+ waitIdle();
+ ZY1000_PEEK(ZY1000_JTAG_BASE+0x18, value);
+ VERBOSE(LOG_INFO("getShiftValue %08x (flipped)", value));
+ return value;
+}
+#endif
+
+#if 0
+static void shiftValueInnerFlip(const tap_state_t state, const tap_state_t endState, int repeat, cyg_uint32 value)
+{
+ VERBOSE(LOG_INFO("shiftValueInner %s %s %d %08x (flipped)", tap_state_name(state), tap_state_name(endState), repeat, value));
+ cyg_uint32 a,b;
+ a=state;
+ b=endState;
+ ZY1000_POKE(ZY1000_JTAG_BASE+0xc, value);
+ ZY1000_POKE(ZY1000_JTAG_BASE+0x8, (1<<15)|(repeat<<8)|(a<<4)|b);
+ VERBOSE(getShiftValueFlip());
+}
+#endif
+
+extern int jtag_check_value(u8 *captured, void *priv);
+
+static void gotoEndState(void)
+{
+ setCurrentState(cmd_queue_end_state);
+}
+
+static __inline void scanFields(int num_fields, scan_field_t *fields, tap_state_t shiftState, tap_state_t end_state)
+{
+ int i;
+ int j;
+ int k;
+
+ for (i = 0; i < num_fields; i++)
+ {
+ cyg_uint32 value;
+
+ static u8 *in_buff=NULL; /* pointer to buffer for scanned data */
+ static int in_buff_size=0;
+ u8 *inBuffer=NULL;
+
+
+ // figure out where to store the input data
+ int num_bits=fields[i].num_bits;
+ if (fields[i].in_value!=NULL)
+ {
+ inBuffer=fields[i].in_value;
+ }
+
+ // here we shuffle N bits out/in
+ j=0;
+ while (j<num_bits)
+ {
+ tap_state_t pause_state;
+ int l;
+ k=num_bits-j;
+ pause_state=(shiftState==TAP_DRSHIFT)?TAP_DRSHIFT:TAP_IRSHIFT;
+ if (k>32)
+ {
+ k=32;
+ /* we have more to shift out */
+ } else if (i == num_fields-1)
+ {
+ /* this was the last to shift out this time */
+ pause_state=end_state;
+ }
+
+ // we have (num_bits+7)/8 bytes of bits to toggle out.
+ // bits are pushed out LSB to MSB
+ value=0;
+ if (fields[i].out_value!=NULL)
+ {
+ for (l=0; l<k; l+=8)
+ {
+ value|=fields[i].out_value[(j+l)/8]<<l;
+ }
+ }
+ /* mask away unused bits for easier debugging */
+ value&=~(((u32)0xffffffff)<<k);
+
+ shiftValueInner(shiftState, pause_state, k, value);
+
+ if (inBuffer!=NULL)
+ {
+ // data in, LSB to MSB
+ value=getShiftValue();
+ // we're shifting in data to MSB, shift data to be aligned for returning the value
+ value >>= 32-k;
+
+ for (l=0; l<k; l+=8)
+ {
+ inBuffer[(j+l)/8]=(value>>l)&0xff;
+ }
+ }
+ j+=k;
+ }
+ }
+}
+
+int interface_jtag_add_end_state(tap_state_t state)
+{
+ return ERROR_OK;
+}
+
+
+int interface_jtag_add_ir_scan(int num_fields, const scan_field_t *fields, tap_state_t state)
+{
+
+ int j;
+ int scan_size = 0;
+ jtag_tap_t *tap, *nextTap;
+ for(tap = jtag_NextEnabledTap(NULL); tap!= NULL; tap=nextTap)
+ {
+ nextTap=jtag_NextEnabledTap(tap);
+ tap_state_t end_state;
+ if (nextTap==NULL)
+ {
+ end_state = cmd_queue_end_state;
+ } else
+ {
+ end_state = TAP_IRSHIFT;
+ }
+
+ int found = 0;
+
+ scan_size = tap->ir_length;
+
+ /* search the list */
+ for (j=0; j < num_fields; j++)
+ {
+ if (tap == fields[j].tap)
+ {
+ found = 1;
+
+ scanFields(1, fields+j, TAP_IRSHIFT, end_state);
+ /* update device information */
+ buf_cpy(fields[j].out_value, tap->cur_instr, scan_size);
+
+ tap->bypass = 0;
+ break;
+ }
+ }
+
+ if (!found)
+ {
+ /* if a device isn't listed, set it to BYPASS */
+ u8 ones[]={0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff};
+
+ scan_field_t tmp;
+ memset(&tmp, 0, sizeof(tmp));
+ tmp.out_value = ones;
+ tmp.num_bits = scan_size;
+ scanFields(1, &tmp, TAP_IRSHIFT, end_state);
+ /* update device information */
+ buf_cpy(tmp.out_value, tap->cur_instr, scan_size);
+ tap->bypass = 1;
+ }
+ }
+
+ return ERROR_OK;
+}
+
+
+
+
+
+int interface_jtag_add_plain_ir_scan(int num_fields, const scan_field_t *fields, tap_state_t state)
+{
+ scanFields(num_fields, fields, TAP_IRSHIFT, cmd_queue_end_state);
+
+ return ERROR_OK;
+}
+
+/*extern jtag_command_t **jtag_get_last_command_p(void);*/
+
+int interface_jtag_add_dr_scan(int num_fields, const scan_field_t *fields, tap_state_t state)
+{
+
+ int j;
+ jtag_tap_t *tap, *nextTap;
+ for(tap = jtag_NextEnabledTap(NULL); tap!= NULL; tap=nextTap)
+ {
+ nextTap=jtag_NextEnabledTap(tap);
+ int found=0;
+ tap_state_t end_state;
+ if (nextTap==NULL)
+ {
+ end_state = cmd_queue_end_state;
+ } else
+ {
+ end_state = TAP_DRSHIFT;
+ }
+
+ for (j=0; j < num_fields; j++)
+ {
+ if (tap == fields[j].tap)
+ {
+ found = 1;
+
+ scanFields(1, fields+j, TAP_DRSHIFT, end_state);
+ }
+ }
+ if (!found)
+ {
+ scan_field_t tmp;
+ /* program the scan field to 1 bit length, and ignore it's value */
+ tmp.num_bits = 1;
+ tmp.out_value = NULL;
+ tmp.in_value = NULL;
+
+ scanFields(1, &tmp, TAP_DRSHIFT, end_state);
+ }
+ else
+ {
+ }
+ }
+ return ERROR_OK;
+}
+
+int interface_jtag_add_plain_dr_scan(int num_fields, const scan_field_t *fields, tap_state_t state)
+{
+ scanFields(num_fields, fields, TAP_DRSHIFT, cmd_queue_end_state);
+ return ERROR_OK;
+}
+
+
+int interface_jtag_add_tlr()
+{
+ setCurrentState(TAP_RESET);
+ return ERROR_OK;
+}
+
+
+
+
+extern int jtag_nsrst_delay;
+extern int jtag_ntrst_delay;
+
+int interface_jtag_add_reset(int req_trst, int req_srst)
+{
+ zy1000_reset(req_trst, req_srst);
+ return ERROR_OK;
+}
+
+static int zy1000_jtag_add_clocks(int num_cycles, tap_state_t state, tap_state_t clockstate)
+{
+ /* num_cycles can be 0 */
+ setCurrentState(clockstate);
+
+ /* execute num_cycles, 32 at the time. */
+ int i;
+ for (i=0; i<num_cycles; i+=32)
+ {
+ int num;
+ num=32;
+ if (num_cycles-i<num)
+ {
+ num=num_cycles-i;
+ }
+ shiftValueInner(clockstate, clockstate, num, 0);
+ }
+
+#if !TEST_MANUAL()
+ /* finish in end_state */
+ setCurrentState(state);
+#else
+ tap_state_t t=TAP_IDLE;
+ /* test manual drive code on any target */
+ int tms;
+ u8 tms_scan = tap_get_tms_path(t, state);
+ int tms_count = tap_get_tms_path_len(tap_get_state(), tap_get_end_state());
+
+ for (i = 0; i < tms_count; i++)
+ {
+ tms = (tms_scan >> i) & 1;
+ waitIdle();
+ ZY1000_POKE(ZY1000_JTAG_BASE+0x28, tms);
+ }
+ waitIdle();
+ ZY1000_POKE(ZY1000_JTAG_BASE+0x20, state);
+#endif
+
+
+ return ERROR_OK;
+}
+
+int interface_jtag_add_runtest(int num_cycles, tap_state_t state)
+{
+ return zy1000_jtag_add_clocks(num_cycles, state, TAP_IDLE);
+}
+
+int interface_jtag_add_clocks(int num_cycles)
+{
+ return zy1000_jtag_add_clocks(num_cycles, cmd_queue_cur_state, cmd_queue_end_state);
+}
+
+int interface_jtag_add_sleep(u32 us)
+{
+ jtag_sleep(us);
+ return ERROR_OK;
+}
+
+int interface_jtag_add_pathmove(int num_states, const tap_state_t *path)
+{
+ int state_count;
+ int tms = 0;
+
+ /*wait for the fifo to be empty*/
+ waitIdle();
+
+ state_count = 0;
+
+ tap_state_t cur_state=cmd_queue_cur_state;
+
+ while (num_states)
+ {
+ if (tap_state_transition(cur_state, false) == path[state_count])
+ {
+ tms = 0;
+ }
+ else if (tap_state_transition(cur_state, true) == path[state_count])
+ {
+ tms = 1;
+ }
+ else
+ {
+ LOG_ERROR("BUG: %s -> %s isn't a valid TAP transition", tap_state_name(cur_state), tap_state_name(path[state_count]));
+ exit(-1);
+ }
+
+ waitIdle();
+ ZY1000_POKE(ZY1000_JTAG_BASE+0x28, tms);
+
+ cur_state = path[state_count];
+ state_count++;
+ num_states--;
+ }
+
+ waitIdle();
+ ZY1000_POKE(ZY1000_JTAG_BASE+0x20, cur_state);
+ return ERROR_OK;
+}
+
+
+
+void embeddedice_write_dcc(jtag_tap_t *tap, int reg_addr, u8 *buffer, int little, int count)
+{
+// static int const reg_addr=0x5;
+ tap_state_t end_state=cmd_queue_end_state;
+ if (jtag_NextEnabledTap(jtag_NextEnabledTap(NULL))==NULL)
+ {
+ /* better performance via code duplication */
+ if (little)
+ {
+ int i;
+ for (i = 0; i < count; i++)
+ {
+ shiftValueInner(TAP_DRSHIFT, TAP_DRSHIFT, 32, fast_target_buffer_get_u32(buffer, 1));
+ shiftValueInner(TAP_DRSHIFT, end_state, 6, reg_addr|(1<<5));
+ buffer+=4;
+ }
+ } else
+ {
+ int i;
+ for (i = 0; i < count; i++)
+ {
+ shiftValueInner(TAP_DRSHIFT, TAP_DRSHIFT, 32, fast_target_buffer_get_u32(buffer, 0));
+ shiftValueInner(TAP_DRSHIFT, end_state, 6, reg_addr|(1<<5));
+ buffer+=4;
+ }
+ }
+ }
+ else
+ {
+ int i;
+ for (i = 0; i < count; i++)
+ {
+ embeddedice_write_reg_inner(tap, reg_addr, fast_target_buffer_get_u32(buffer, little));
+ buffer += 4;
+ }
+ }
+}
+
+int loadFile(const char *fileName, void **data, int *len);
+
+/* boolean parameter stored on config */
+int boolParam(char *var)
+{
+ bool result = false;
+ char *name = alloc_printf("%s/%s", zylin_config_dir, var);
+ if (name == NULL)
+ return result;
+
+ void *data;
+ int len;
+ if (loadFile(name, &data, &len) == ERROR_OK)
+ {
+ if (len > 1)
+ len = 1;
+ result = strncmp((char *) data, "1", len) == 0;
+ free(data);
+ }
+ free(name);
+ return result;
+}
+
+
Code Review / openocd.git / blobdiff