git.gag.com Git - fw/openocd/blob - src/flash/avrf.c

   1 /***************************************************************************
   2  *   Copyright (C) 2009 by Simon Qian                                      *
   3  *   SimonQian@SimonQian.com                                               *
   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 "replacements.h"
  25
  26 #include "avrf.h"
  27 #include "avrt.h"
  28 #include "flash.h"
  29 #include "target.h"
  30 #include "log.h"
  31 #include "algorithm.h"
  32 #include "binarybuffer.h"
  33
  34 #include <stdlib.h>
  35 #include <string.h>
  36
  37 /* AVR_JTAG_Instructions */
  38 #define AVR_JTAG_INS_LEN                                                        4
  39 // Public Instructions:
  40 #define AVR_JTAG_INS_EXTEST                                                     0x00
  41 #define AVR_JTAG_INS_IDCODE                                                     0x01
  42 #define AVR_JTAG_INS_SAMPLE_PRELOAD                                     0x02
  43 #define AVR_JTAG_INS_BYPASS                                                     0x0F
  44 // AVR Specified Public Instructions:
  45 #define AVR_JTAG_INS_AVR_RESET                                          0x0C
  46 #define AVR_JTAG_INS_PROG_ENABLE                                        0x04
  47 #define AVR_JTAG_INS_PROG_COMMANDS                                      0x05
  48 #define AVR_JTAG_INS_PROG_PAGELOAD                                      0x06
  49 #define AVR_JTAG_INS_PROG_PAGEREAD                                      0x07
  50
  51 // Data Registers:
  52 #define AVR_JTAG_REG_Bypass_Len                                         1
  53 #define AVR_JTAG_REG_DeviceID_Len                                       32
  54
  55 #define AVR_JTAG_REG_Reset_Len                                          1
  56 #define AVR_JTAG_REG_JTAGID_Len                                         32
  57 #define AVR_JTAG_REG_ProgrammingEnable_Len                      16
  58 #define AVR_JTAG_REG_ProgrammingCommand_Len                     15
  59 #define AVR_JTAG_REG_FlashDataByte_Len                          16
  60
  61 avrf_type_t avft_chips_info[] =
  62 {
  63 //       name,                  chip_id,        flash_page_size,        flash_page_num, eeprom_page_size,       eeprom_page_num
  64         {"atmega128",   0x9702,         256,                            512,                    8,                                      512},
  65 };
  66
  67 static int avrf_register_commands(struct command_context_s *cmd_ctx);
  68 static int avrf_flash_bank_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc, struct flash_bank_s *bank);
  69 static int avrf_erase(struct flash_bank_s *bank, int first, int last);
  70 static int avrf_protect(struct flash_bank_s *bank, int set, int first, int last);
  71 static int avrf_write(struct flash_bank_s *bank, u8 *buffer, u32 offset, u32 count);
  72 static int avrf_probe(struct flash_bank_s *bank);
  73 static int avrf_auto_probe(struct flash_bank_s *bank);
  74 //static int avrf_handle_part_id_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
  75 static int avrf_protect_check(struct flash_bank_s *bank);
  76 static int avrf_info(struct flash_bank_s *bank, char *buf, int buf_size);
  77
  78 static int avrf_handle_mass_erase_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
  79
  80 extern int avr_jtag_sendinstr(jtag_tap_t *tap, u8 *ir_in, u8 ir_out);
  81 extern int avr_jtag_senddat(jtag_tap_t *tap, u32 *dr_in, u32 dr_out, int len);
  82
  83 extern int mcu_write_ir(jtag_tap_t *tap, u8 *ir_in, u8 *ir_out, int ir_len, int rti);
  84 extern int mcu_write_dr(jtag_tap_t *tap, u8 *ir_in, u8 *ir_out, int dr_len, int rti);
  85 extern int mcu_write_ir_u8(jtag_tap_t *tap, u8 *ir_in, u8 ir_out, int ir_len, int rti);
  86 extern int mcu_write_dr_u8(jtag_tap_t *tap, u8 *ir_in, u8 ir_out, int dr_len, int rti);
  87 extern int mcu_write_ir_u16(jtag_tap_t *tap, u16 *ir_in, u16 ir_out, int ir_len, int rti);
  88 extern int mcu_write_dr_u16(jtag_tap_t *tap, u16 *ir_in, u16 ir_out, int dr_len, int rti);
  89 extern int mcu_write_ir_u32(jtag_tap_t *tap, u32 *ir_in, u32 ir_out, int ir_len, int rti);
  90 extern int mcu_write_dr_u32(jtag_tap_t *tap, u32 *ir_in, u32 ir_out, int dr_len, int rti);
  91 extern int mcu_execute_queue(void);
  92
  93 flash_driver_t avr_flash =
  94 {
  95         .name = "avr",
  96         .register_commands = avrf_register_commands,
  97         .flash_bank_command = avrf_flash_bank_command,
  98         .erase = avrf_erase,
  99         .protect = avrf_protect,
 100         .write = avrf_write,
 101         .probe = avrf_probe,
 102         .auto_probe = avrf_auto_probe,
 103         .erase_check = default_flash_mem_blank_check,
 104         .protect_check = avrf_protect_check,
 105         .info = avrf_info
 106 };
 107
 108 /* avr program functions */
 109 static int avr_jtag_reset(avr_common_t *avr, u32 reset)
 110 {
 111         avr_jtag_sendinstr(avr->jtag_info.tap, NULL, AVR_JTAG_INS_AVR_RESET);
 112         avr_jtag_senddat(avr->jtag_info.tap, NULL, reset ,AVR_JTAG_REG_Reset_Len);
 113
 114         return ERROR_OK;
 115 }
 116
 117 static int avr_jtag_read_jtagid(avr_common_t *avr, u32 *id)
 118 {
 119         avr_jtag_sendinstr(avr->jtag_info.tap, NULL, AVR_JTAG_INS_IDCODE);
 120         avr_jtag_senddat(avr->jtag_info.tap, id, 0, AVR_JTAG_REG_JTAGID_Len);
 121
 122         return ERROR_OK;
 123 }
 124
 125 static int avr_jtagprg_enterprogmode(avr_common_t *avr)
 126 {
 127         avr_jtag_reset(avr, 1);
 128
 129         avr_jtag_sendinstr(avr->jtag_info.tap, NULL, AVR_JTAG_INS_PROG_ENABLE);
 130         avr_jtag_senddat(avr->jtag_info.tap, NULL, 0xA370, AVR_JTAG_REG_ProgrammingEnable_Len);
 131
 132         return ERROR_OK;
 133 }
 134
 135 static int avr_jtagprg_leaveprogmode(avr_common_t *avr)
 136 {
 137         avr_jtag_sendinstr(avr->jtag_info.tap, NULL, AVR_JTAG_INS_PROG_COMMANDS);
 138         avr_jtag_senddat(avr->jtag_info.tap, NULL, 0x2300, AVR_JTAG_REG_ProgrammingCommand_Len);
 139         avr_jtag_senddat(avr->jtag_info.tap, NULL, 0x3300, AVR_JTAG_REG_ProgrammingCommand_Len);
 140
 141         avr_jtag_sendinstr(avr->jtag_info.tap, NULL, AVR_JTAG_INS_PROG_ENABLE);
 142         avr_jtag_senddat(avr->jtag_info.tap, NULL, 0, AVR_JTAG_REG_ProgrammingEnable_Len);
 143
 144         avr_jtag_reset(avr, 0);
 145
 146         return ERROR_OK;
 147 }
 148
 149 static int avr_jtagprg_chiperase(avr_common_t *avr)
 150 {
 151         u32 poll_value;
 152
 153         avr_jtag_sendinstr(avr->jtag_info.tap, NULL, AVR_JTAG_INS_PROG_COMMANDS);
 154         avr_jtag_senddat(avr->jtag_info.tap, NULL, 0x2380, AVR_JTAG_REG_ProgrammingCommand_Len);
 155         avr_jtag_senddat(avr->jtag_info.tap, NULL, 0x3180, AVR_JTAG_REG_ProgrammingCommand_Len);
 156         avr_jtag_senddat(avr->jtag_info.tap, NULL, 0x3380, AVR_JTAG_REG_ProgrammingCommand_Len);
 157         avr_jtag_senddat(avr->jtag_info.tap, NULL, 0x3380, AVR_JTAG_REG_ProgrammingCommand_Len);
 158
 159         do{
 160                 poll_value = 0;
 161                 avr_jtag_senddat(avr->jtag_info.tap, &poll_value, 0x3380, AVR_JTAG_REG_ProgrammingCommand_Len);
 162                 if (ERROR_OK != mcu_execute_queue())
 163                 {
 164                         return ERROR_FAIL;
 165                 }
 166                 LOG_DEBUG("poll_value = 0x%04X", poll_value);
 167         }while(!(poll_value & 0x0200));
 168
 169         return ERROR_OK;
 170 }
 171
 172 static int avr_jtagprg_writeflashpage(avr_common_t *avr, u8 *page_buf, u32 buf_size, u32 addr, u32 page_size)
 173 {
 174         u32 i, poll_value;
 175
 176         avr_jtag_sendinstr(avr->jtag_info.tap, NULL, AVR_JTAG_INS_PROG_COMMANDS);
 177         avr_jtag_senddat(avr->jtag_info.tap, NULL, 0x2310, AVR_JTAG_REG_ProgrammingCommand_Len);
 178
 179         // load addr high byte
 180         avr_jtag_senddat(avr->jtag_info.tap, NULL, 0x0700 | ((addr >> 9) & 0xFF), AVR_JTAG_REG_ProgrammingCommand_Len);
 181
 182         // load addr low byte
 183         avr_jtag_senddat(avr->jtag_info.tap, NULL, 0x0300 | ((addr >> 1) & 0xFF), AVR_JTAG_REG_ProgrammingCommand_Len);
 184
 185         avr_jtag_sendinstr(avr->jtag_info.tap, NULL, AVR_JTAG_INS_PROG_PAGELOAD);
 186
 187         for (i = 0; i < page_size; i++)
 188         {
 189                 if (i < buf_size)
 190                 {
 191                         avr_jtag_senddat(avr->jtag_info.tap, NULL, page_buf[i], 8);
 192                 }
 193                 else
 194                 {
 195                         avr_jtag_senddat(avr->jtag_info.tap, NULL, 0xFF, 8);
 196                 }
 197         }
 198
 199         avr_jtag_sendinstr(avr->jtag_info.tap, NULL, AVR_JTAG_INS_PROG_COMMANDS);
 200
 201         avr_jtag_senddat(avr->jtag_info.tap, NULL, 0x3700, AVR_JTAG_REG_ProgrammingCommand_Len);
 202         avr_jtag_senddat(avr->jtag_info.tap, NULL, 0x3500, AVR_JTAG_REG_ProgrammingCommand_Len);
 203         avr_jtag_senddat(avr->jtag_info.tap, NULL, 0x3700, AVR_JTAG_REG_ProgrammingCommand_Len);
 204         avr_jtag_senddat(avr->jtag_info.tap, NULL, 0x3700, AVR_JTAG_REG_ProgrammingCommand_Len);
 205
 206         do{
 207                 poll_value = 0;
 208                 avr_jtag_senddat(avr->jtag_info.tap, &poll_value, 0x3700, AVR_JTAG_REG_ProgrammingCommand_Len);
 209                 if (ERROR_OK != mcu_execute_queue())
 210                 {
 211                         return ERROR_FAIL;
 212                 }
 213                 LOG_DEBUG("poll_value = 0x%04X", poll_value);
 214         }while(!(poll_value & 0x0200));
 215
 216         return ERROR_OK;
 217 }
 218
 219 /* interface command */
 220 static int avrf_register_commands(struct command_context_s *cmd_ctx)
 221 {
 222         command_t *avr_cmd = register_command(cmd_ctx, NULL, "avr", NULL, COMMAND_ANY, "avr flash specific commands");
 223
 224         register_command(cmd_ctx, avr_cmd, "mass_erase", avrf_handle_mass_erase_command, COMMAND_EXEC,
 225                                          "mass erase device");
 226
 227         return ERROR_OK;
 228 }
 229
 230 static int avrf_flash_bank_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc, struct flash_bank_s *bank)
 231 {
 232         avrf_flash_bank_t *avrf_info;
 233
 234         if (argc < 6)
 235         {
 236                 LOG_WARNING("incomplete flash_bank avr configuration");
 237                 return ERROR_FLASH_BANK_INVALID;
 238         }
 239
 240         avrf_info = malloc(sizeof(avrf_flash_bank_t));
 241         bank->driver_priv = avrf_info;
 242
 243         avrf_info->probed = 0;
 244
 245         return ERROR_OK;
 246 }
 247
 248 static int avrf_erase(struct flash_bank_s *bank, int first, int last)
 249 {
 250         LOG_INFO(__FUNCTION__);
 251         return ERROR_OK;
 252 }
 253
 254 static int avrf_protect(struct flash_bank_s *bank, int set, int first, int last)
 255 {
 256         LOG_INFO(__FUNCTION__);
 257         return ERROR_OK;
 258 }
 259
 260 static int avrf_write(struct flash_bank_s *bank, u8 *buffer, u32 offset, u32 count)
 261 {
 262         target_t *target = bank->target;
 263         avr_common_t *avr = target->arch_info;
 264         u32 cur_size, cur_buffer_size, page_size;
 265
 266         if (bank->target->state != TARGET_HALTED)
 267         {
 268                 LOG_ERROR("Target not halted");
 269                 return ERROR_TARGET_NOT_HALTED;
 270         }
 271
 272         page_size = bank->sectors[0].size;
 273         if ((offset % page_size) != 0)
 274         {
 275                 LOG_WARNING("offset 0x%x breaks required %d-byte alignment", offset, page_size);
 276                 return ERROR_FLASH_DST_BREAKS_ALIGNMENT;
 277         }
 278
 279         LOG_DEBUG("offset is 0x%08X", offset);
 280         LOG_DEBUG("count is %d", count);
 281
 282         if (ERROR_OK != avr_jtagprg_enterprogmode(avr))
 283         {
 284                 return ERROR_FAIL;
 285         }
 286
 287         cur_size = 0;
 288         while(count > 0)
 289         {
 290                 if (count > page_size)
 291                 {
 292                         cur_buffer_size = page_size;
 293                 }
 294                 else
 295                 {
 296                         cur_buffer_size = count;
 297                 }
 298                 avr_jtagprg_writeflashpage(avr, buffer + cur_size, cur_buffer_size, offset + cur_size, page_size);
 299                 count -= cur_buffer_size;
 300                 cur_size += cur_buffer_size;
 301
 302                 keep_alive();
 303         }
 304
 305         return avr_jtagprg_leaveprogmode(avr);
 306 }
 307
 308 #define EXTRACT_MFG(X)  (((X) & 0xffe) >> 1)
 309 #define EXTRACT_PART(X) (((X) & 0xffff000) >> 12)
 310 #define EXTRACT_VER(X)  (((X) & 0xf0000000) >> 28)
 311 static int avrf_probe(struct flash_bank_s *bank)
 312 {
 313         target_t *target = bank->target;
 314         avrf_flash_bank_t *avrf_info = bank->driver_priv;
 315         avr_common_t *avr = target->arch_info;
 316         avrf_type_t *avr_info = NULL;
 317         int i;
 318         u32 device_id;
 319
 320         if (bank->target->state != TARGET_HALTED)
 321         {
 322                 LOG_ERROR("Target not halted");
 323                 return ERROR_TARGET_NOT_HALTED;
 324         }
 325
 326         avrf_info->probed = 0;
 327
 328         avr_jtag_read_jtagid(avr, &device_id);
 329         if (ERROR_OK != mcu_execute_queue())
 330         {
 331                 return ERROR_FAIL;
 332         }
 333
 334         LOG_INFO( "device id = 0x%08x", device_id );
 335         if (EXTRACT_MFG(device_id) != 0x1F)
 336         {
 337                 LOG_ERROR("0x%X is invalid Manufacturer for avr, 0x%X is expected", EXTRACT_MFG(device_id), 0x1F);
 338         }
 339
 340         for (i = 0; i < (int)(sizeof(avft_chips_info) / sizeof(avft_chips_info[0])); i++)
 341         {
 342                 if (avft_chips_info[i].chip_id == EXTRACT_PART(device_id))
 343                 {
 344                         avr_info = &avft_chips_info[i];
 345                         LOG_INFO("target device is %s", avr_info->name);
 346                         break;
 347                 }
 348         }
 349
 350         if (avr_info != NULL)
 351         {
 352                 // chip found
 353                 bank->base = 0x00000000;
 354                 bank->size = (avr_info->flash_page_size * avr_info->flash_page_num);
 355                 bank->num_sectors = avr_info->flash_page_num;
 356                 bank->sectors = malloc(sizeof(flash_sector_t) * avr_info->flash_page_num);
 357
 358                 for (i = 0; i < avr_info->flash_page_num; i++)
 359                 {
 360                         bank->sectors[i].offset = i * avr_info->flash_page_size;
 361                         bank->sectors[i].size = avr_info->flash_page_size;
 362                         bank->sectors[i].is_erased = -1;
 363                         bank->sectors[i].is_protected = 1;
 364                 }
 365
 366                 avrf_info->probed = 1;
 367                 return ERROR_OK;
 368         }
 369         else
 370         {
 371                 // chip not supported
 372                 LOG_ERROR("0x%X is not support for avr", EXTRACT_PART(device_id));
 373
 374                 avrf_info->probed = 1;
 375                 return ERROR_FAIL;
 376         }
 377 }
 378
 379 static int avrf_auto_probe(struct flash_bank_s *bank)
 380 {
 381         avrf_flash_bank_t *avrf_info = bank->driver_priv;
 382         if (avrf_info->probed)
 383                 return ERROR_OK;
 384         return avrf_probe(bank);
 385 }
 386
 387 static int avrf_protect_check(struct flash_bank_s *bank)
 388 {
 389         LOG_INFO(__FUNCTION__);
 390         return ERROR_OK;
 391 }
 392
 393 static int avrf_info(struct flash_bank_s *bank, char *buf, int buf_size)
 394 {
 395         target_t *target = bank->target;
 396         avr_common_t *avr = target->arch_info;
 397         avrf_type_t *avr_info = NULL;
 398         int i;
 399         u32 device_id;
 400
 401         if (bank->target->state != TARGET_HALTED)
 402         {
 403                 LOG_ERROR("Target not halted");
 404                 return ERROR_TARGET_NOT_HALTED;
 405         }
 406
 407         avr_jtag_read_jtagid(avr, &device_id);
 408         if (ERROR_OK != mcu_execute_queue())
 409         {
 410                 return ERROR_FAIL;
 411         }
 412
 413         LOG_INFO( "device id = 0x%08x", device_id );
 414         if (EXTRACT_MFG(device_id) != 0x1F)
 415         {
 416                 LOG_ERROR("0x%X is invalid Manufacturer for avr, 0x%X is expected", EXTRACT_MFG(device_id), 0x1F);
 417         }
 418
 419         for (i = 0; i < (int)(sizeof(avft_chips_info) / sizeof(avft_chips_info[0])); i++)
 420         {
 421                 if (avft_chips_info[i].chip_id == EXTRACT_PART(device_id))
 422                 {
 423                         avr_info = &avft_chips_info[i];
 424                         LOG_INFO("target device is %s", avr_info->name);
 425
 426                         break;
 427                 }
 428         }
 429
 430         if (avr_info != NULL)
 431         {
 432                 // chip found
 433                 snprintf(buf, buf_size, "%s - Rev: 0x%X", avr_info->name, EXTRACT_VER(device_id));
 434                 return ERROR_OK;
 435         }
 436         else
 437         {
 438                 // chip not supported
 439                 snprintf(buf, buf_size, "Cannot identify target as a avr\n");
 440                 return ERROR_FLASH_OPERATION_FAILED;
 441         }
 442 }
 443
 444 static int avrf_mass_erase(struct flash_bank_s *bank)
 445 {
 446         target_t *target = bank->target;
 447         avr_common_t *avr = target->arch_info;
 448
 449         if (target->state != TARGET_HALTED)
 450         {
 451                 LOG_ERROR("Target not halted");
 452                 return ERROR_TARGET_NOT_HALTED;
 453         }
 454
 455         if ((ERROR_OK != avr_jtagprg_enterprogmode(avr))
 456                 || (ERROR_OK != avr_jtagprg_chiperase(avr))
 457                 || (ERROR_OK != avr_jtagprg_leaveprogmode(avr)))
 458         {
 459                 return ERROR_FAIL;
 460         }
 461
 462         return ERROR_OK;
 463 }
 464
 465 static int avrf_handle_mass_erase_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
 466 {
 467         flash_bank_t *bank;
 468         int i;
 469
 470         if (argc < 1)
 471         {
 472                 command_print(cmd_ctx, "avr mass_erase <bank>");
 473                 return ERROR_OK;
 474         }
 475
 476         bank = get_flash_bank_by_num(strtoul(args[0], NULL, 0));
 477         if (!bank)
 478         {
 479                 command_print(cmd_ctx, "flash bank '#%s' is out of bounds", args[0]);
 480                 return ERROR_OK;
 481         }
 482
 483         if (avrf_mass_erase(bank) == ERROR_OK)
 484         {
 485                 /* set all sectors as erased */
 486                 for (i = 0; i < bank->num_sectors; i++)
 487                 {
 488                         bank->sectors[i].is_erased = 1;
 489                 }
 490
 491                 command_print(cmd_ctx, "avr mass erase complete");
 492         }
 493         else
 494         {
 495                 command_print(cmd_ctx, "avr mass erase failed");
 496         }
 497
 498         LOG_DEBUG(__FUNCTION__);
 499         return ERROR_OK;
 500 }