src/target/dsp563xx_once.c

   1 /***************************************************************************
   2  *   Copyright (C) 2009 by Mathias Kuester                                 *
   3  *   mkdorg@users.sourceforge.net                                          *
   4  *                                                                         *
   5  *   This program is free software; you can redistribute it and/or modify  *
   6  *   it under the terms of the GNU General Public License as published by  *
   7  *   the Free Software Foundation; either version 2 of the License, or     *
   8  *   (at your option) any later version.                                   *
   9  *                                                                         *
  10  *   This program is distributed in the hope that it will be useful,       *
  11  *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
  12  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         *
  13  *   GNU General Public License for more details.                          *
  14  *                                                                         *
  15  *   You should have received a copy of the GNU General Public License     *
  16  *   along with this program; if not, write to the                         *
  17  *   Free Software Foundation, Inc.,                                       *
  18  *   59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.             *
  19  ***************************************************************************/
  20 #ifdef HAVE_CONFIG_H
  21 #include "config.h"
  22 #endif
  23
  24 #include <jim.h>
  25
  26 #include "target.h"
  27 #include "target_type.h"
  28 #include "register.h"
  29 #include "dsp563xx.h"
  30 #include "dsp563xx_once.h"
  31
  32 #define JTAG_STATUS_NORMAL              0x01
  33 #define JTAG_STATUS_STOPWAIT            0x05
  34 #define JTAG_STATUS_BUSY                0x09
  35 #define JTAG_STATUS_DEBUG               0x0d
  36
  37 #define JTAG_INSTR_EXTEST               0x00
  38 #define JTAG_INSTR_SAMPLE_PRELOAD       0x01
  39 #define JTAG_INSTR_IDCODE               0x02
  40 #define JTAG_INSTR_HIZ                  0x04
  41 #define JTAG_INSTR_CLAMP                0x05
  42 #define JTAG_INSTR_ENABLE_ONCE          0x06
  43 #define JTAG_INSTR_DEBUG_REQUEST        0x07
  44 #define JTAG_INSTR_BYPASS               0x0F
  45
  46 static inline int dsp563xx_write_dr(struct jtag_tap *tap, uint8_t * dr_in, uint8_t * dr_out, int dr_len, int rti)
  47 {
  48         if (NULL == tap)
  49         {
  50                 LOG_ERROR("invalid tap");
  51                 return ERROR_FAIL;
  52         }
  53
  54         jtag_add_plain_dr_scan(dr_len, dr_out, dr_in, TAP_IDLE);
  55
  56         return ERROR_OK;
  57 }
  58
  59 static inline int dsp563xx_write_dr_u8(struct jtag_tap *tap, uint8_t * dr_in, uint8_t dr_out, int dr_len, int rti)
  60 {
  61         if (dr_len > 8)
  62         {
  63                 LOG_ERROR("dr_len overflow, maxium is 8");
  64                 return ERROR_FAIL;
  65         }
  66
  67         return dsp563xx_write_dr(tap, dr_in, &dr_out, dr_len, rti);
  68 }
  69
  70 static inline int dsp563xx_write_dr_u32(struct jtag_tap *tap, uint32_t * dr_in, uint32_t dr_out, int dr_len, int rti)
  71 {
  72         if (dr_len > 32)
  73         {
  74                 LOG_ERROR("dr_len overflow, maxium is 32");
  75                 return ERROR_FAIL;
  76         }
  77
  78         return dsp563xx_write_dr(tap, (uint8_t *) dr_in, (uint8_t *) & dr_out, dr_len, rti);
  79 }
  80
  81 /** single word instruction */
  82 static inline int dsp563xx_once_ir_exec(struct jtag_tap *tap, uint8_t instr, uint8_t rw, uint8_t go, uint8_t ex)
  83 {
  84         int err;
  85
  86         if ((err = dsp563xx_write_dr_u8(tap, 0, instr | (ex << 5) | (go << 6) | (rw << 7), 8, 0)) != ERROR_OK)
  87                 return err;
  88
  89         return jtag_execute_queue();
  90 }
  91
  92 /** single word instruction */
  93 static inline int dsp563xx_once_ir_exec_nq(struct jtag_tap *tap, uint8_t instr, uint8_t rw, uint8_t go, uint8_t ex)
  94 {
  95         return dsp563xx_write_dr_u8(tap, 0, instr | (ex << 5) | (go << 6) | (rw << 7), 8, 0);
  96 }
  97
  98 /* IR and DR functions */
  99 static inline int dsp563xx_write_ir(struct jtag_tap *tap, uint8_t * ir_in, uint8_t * ir_out, int ir_len, int rti)
 100 {
 101         if (NULL == tap)
 102         {
 103                 LOG_ERROR("invalid tap");
 104                 return ERROR_FAIL;
 105         }
 106         if (ir_len != tap->ir_length)
 107         {
 108                 LOG_ERROR("invalid ir_len");
 109                 return ERROR_FAIL;
 110         }
 111
 112         jtag_add_plain_ir_scan(tap->ir_length, ir_out, ir_in, TAP_IDLE);
 113
 114         return ERROR_OK;
 115 }
 116
 117 static inline int dsp563xx_write_ir_u8(struct jtag_tap *tap, uint8_t * ir_in, uint8_t ir_out, int ir_len, int rti)
 118 {
 119         if (ir_len > 8)
 120         {
 121                 LOG_ERROR("ir_len overflow, maxium is 8");
 122                 return ERROR_FAIL;
 123         }
 124
 125         return dsp563xx_write_ir(tap, ir_in, &ir_out, ir_len, rti);
 126 }
 127
 128 static inline int dsp563xx_jtag_sendinstr(struct jtag_tap *tap, uint8_t * ir_in, uint8_t ir_out)
 129 {
 130         return dsp563xx_write_ir_u8(tap, ir_in, ir_out, tap->ir_length, 1);
 131 }
 132
 133 /** */
 134 int dsp563xx_once_target_status(struct jtag_tap *tap)
 135 {
 136         int err;
 137         uint8_t jtag_status;
 138
 139         if ((err = dsp563xx_jtag_sendinstr(tap, &jtag_status, JTAG_INSTR_ENABLE_ONCE)) != ERROR_OK)
 140                 return err;
 141         if ((err = jtag_execute_queue()) != ERROR_OK)
 142                 return err;
 143
 144         if ((jtag_status & 1) != 1)
 145         {
 146                 return TARGET_UNKNOWN;
 147         }
 148
 149         if (jtag_status != JTAG_STATUS_DEBUG)
 150         {
 151                 return TARGET_RUNNING;
 152         }
 153
 154         return TARGET_HALTED;
 155 }
 156
 157 /** */
 158 int dsp563xx_once_request_debug(struct jtag_tap *tap, int reset_state)
 159 {
 160         int err;
 161         uint8_t ir_in = 0, pattern = 0;
 162         uint32_t retry = 0;
 163
 164         /* in reset state we only get a ACK
 165          * from the interface */
 166         if (reset_state)
 167         {
 168                 pattern = 1;
 169         }
 170         else
 171         {
 172                 pattern = JTAG_STATUS_DEBUG;
 173         }
 174
 175         /* wait until we get the ack */
 176         while (ir_in != pattern)
 177         {
 178                 if ((err = dsp563xx_jtag_sendinstr(tap, &ir_in, JTAG_INSTR_DEBUG_REQUEST)) != ERROR_OK)
 179                         return err;
 180                 if ((err = jtag_execute_queue()) != ERROR_OK)
 181                         return err;
 182
 183                 LOG_DEBUG("debug request: %02X", ir_in);
 184
 185                 if (retry++ == 100)
 186                 {
 187                         return ERROR_TARGET_FAILURE;
 188                 }
 189         }
 190
 191         /* we cant enable the once in reset state */
 192         if (pattern == 1)
 193         {
 194                 return ERROR_OK;
 195         }
 196
 197         /* try to enable once */
 198         retry = 0;
 199         ir_in = 0;
 200         while (ir_in != pattern)
 201         {
 202                 if ((err = dsp563xx_jtag_sendinstr(tap, &ir_in, JTAG_INSTR_ENABLE_ONCE)) != ERROR_OK)
 203                         return err;
 204                 if ((err = jtag_execute_queue()) != ERROR_OK)
 205                         return err;
 206
 207                 LOG_DEBUG("enable once: %02X", ir_in);
 208
 209                 if (retry++ == 100)
 210                 {
 211                         LOG_DEBUG("error");
 212                         return ERROR_TARGET_FAILURE;
 213                 }
 214         }
 215
 216         if (ir_in != JTAG_STATUS_DEBUG)
 217         {
 218                 return ERROR_TARGET_FAILURE;
 219         }
 220
 221         return ERROR_OK;
 222 }
 223
 224 /** once read registers */
 225 int dsp563xx_once_read_register(struct jtag_tap *tap, struct once_reg *regs, int len)
 226 {
 227         int i;
 228         int err;
 229
 230         for (i = 0; i < len; i++)
 231         {
 232                 if ((err = dsp563xx_once_reg_read_ex_nq(tap, regs[i].addr, regs[i].len, &regs[i].reg)) != ERROR_OK)
 233                         return err;
 234         }
 235
 236         return jtag_execute_queue();
 237 /*
 238         for(i=0;i<len;i++)
 239         {
 240                 printf("%08X\n",regs[i].reg);
 241         }
 242 */
 243 }
 244
 245 /** once read register */
 246 int dsp563xx_once_reg_read_ex_nq(struct jtag_tap *tap, uint8_t reg, uint8_t len, uint32_t * data)
 247 {
 248         int err;
 249
 250         if ((err = dsp563xx_once_ir_exec(tap, reg, 1, 0, 0)) != ERROR_OK)
 251                 return err;
 252         return dsp563xx_write_dr_u32(tap, data, 0x00, len, 0);
 253 }
 254
 255 /** once read register */
 256 int dsp563xx_once_reg_read_ex(struct jtag_tap *tap, uint8_t reg, uint8_t len, uint32_t * data)
 257 {
 258         int err;
 259
 260         if ((err = dsp563xx_once_ir_exec(tap, reg, 1, 0, 0)) != ERROR_OK)
 261                 return err;
 262         if ((err = dsp563xx_write_dr_u32(tap, data, 0x00, len, 0)) != ERROR_OK)
 263                 return err;
 264         return jtag_execute_queue();
 265 }
 266
 267 /** once read register */
 268 int dsp563xx_once_reg_read(struct jtag_tap *tap, uint8_t reg, uint32_t * data)
 269 {
 270         int err;
 271
 272         if ((err = dsp563xx_once_ir_exec(tap, reg, 1, 0, 0)) != ERROR_OK)
 273                 return err;
 274         if ((err = dsp563xx_write_dr_u32(tap, data, 0x00, 24, 0)) != ERROR_OK)
 275                 return err;
 276         return jtag_execute_queue();
 277 }
 278
 279 /** once write register */
 280 int dsp563xx_once_reg_write(struct jtag_tap *tap, uint8_t reg, uint32_t data)
 281 {
 282         int err;
 283
 284         if ((err = dsp563xx_once_ir_exec(tap, reg, 0, 0, 0)) != ERROR_OK)
 285                 return err;
 286         if ((err = dsp563xx_write_dr_u32(tap, 0x00, data, 24, 0)) != ERROR_OK)
 287                 return err;
 288         return jtag_execute_queue();
 289 }
 290
 291 /** single word instruction */
 292 int dsp563xx_once_execute_sw_ir(struct jtag_tap *tap, uint32_t opcode)
 293 {
 294         int err;
 295
 296         if ((err = dsp563xx_once_ir_exec(tap, DSP563XX_ONCE_OPDBR, 0, 1, 0)) != ERROR_OK)
 297                 return err;
 298         if ((err = dsp563xx_write_dr_u32(tap, 0, opcode, 24, 0)) != ERROR_OK)
 299                 return err;
 300         return jtag_execute_queue();
 301 }
 302
 303 /** double word instruction */
 304 int dsp563xx_once_execute_dw_ir(struct jtag_tap *tap, uint32_t opcode, uint32_t operand)
 305 {
 306         int err;
 307
 308         if ((err = dsp563xx_once_ir_exec(tap, DSP563XX_ONCE_OPDBR, 0, 0, 0)) != ERROR_OK)
 309                 return err;
 310         if ((err = dsp563xx_write_dr_u32(tap, 0, opcode, 24, 0)) != ERROR_OK)
 311                 return err;
 312         if ((err = jtag_execute_queue()) != ERROR_OK)
 313                 return err;
 314
 315         if ((err = dsp563xx_once_ir_exec(tap, DSP563XX_ONCE_OPDBR, 0, 1, 0)) != ERROR_OK)
 316                 return err;
 317         if ((err = dsp563xx_write_dr_u32(tap, 0, operand, 24, 0)) != ERROR_OK)
 318                 return err;
 319         if ((err = jtag_execute_queue()) != ERROR_OK)
 320                 return err;
 321
 322         return ERROR_OK;
 323 }
 324
 325 /** single word instruction */
 326 int dsp563xx_once_execute_sw_ir_nq(struct jtag_tap *tap, uint32_t opcode)
 327 {
 328         int err;
 329
 330         if ((err = dsp563xx_once_ir_exec_nq(tap, DSP563XX_ONCE_OPDBR, 0, 1, 0)) != ERROR_OK)
 331                 return err;
 332         if ((err = dsp563xx_write_dr_u32(tap, 0, opcode, 24, 0)) != ERROR_OK)
 333                 return err;
 334
 335         return ERROR_OK;
 336 }
 337
 338 /** double word instruction */
 339 int dsp563xx_once_execute_dw_ir_nq(struct jtag_tap *tap, uint32_t opcode, uint32_t operand)
 340 {
 341         int err;
 342
 343         if ((err = dsp563xx_once_ir_exec_nq(tap, DSP563XX_ONCE_OPDBR, 0, 0, 0)) != ERROR_OK)
 344                 return err;
 345         if ((err = dsp563xx_write_dr_u32(tap, 0, opcode, 24, 0)) != ERROR_OK)
 346                 return err;
 347         if ((err = dsp563xx_once_ir_exec_nq(tap, DSP563XX_ONCE_OPDBR, 0, 1, 0)) != ERROR_OK)
 348                 return err;
 349         if ((err = dsp563xx_write_dr_u32(tap, 0, operand, 24, 0)) != ERROR_OK)
 350                 return err;
 351
 352         return ERROR_OK;
 353 }