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

   1 /***************************************************************************
   2  *   Copyright (C) 2011 by Mathias Kuester                                 *
   3  *   kesmtp@freenet.de                                                     *
   4  *                                                                         *
   5  *   Copyright (C) 2011 sleep(5) ltd                                       *
   6  *   tomas@sleepfive.com                                                   *
   7  *                                                                         *
   8  *   This program is free software; you can redistribute it and/or modify  *
   9  *   it under the terms of the GNU General Public License as published by  *
  10  *   the Free Software Foundation; either version 2 of the License, or     *
  11  *   (at your option) any later version.                                   *
  12  *                                                                         *
  13  *   This program is distributed in the hope that it will be useful,       *
  14  *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
  15  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         *
  16  *   GNU General Public License for more details.                          *
  17  *                                                                         *
  18  *   You should have received a copy of the GNU General Public License     *
  19  *   along with this program; if not, write to the                         *
  20  *   Free Software Foundation, Inc.,                                       *
  21  *   59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.             *
  22  ***************************************************************************/
  23
  24 #ifdef HAVE_CONFIG_H
  25 #include "config.h"
  26 #endif
  27
  28 #include "imp.h"
  29 #include "helper/binarybuffer.h"
  30
  31 struct kinetis_flash_bank {
  32         uint32_t nvm_start;
  33 };
  34
  35 static int kinetis_get_master_bank(struct flash_bank *bank,
  36         struct flash_bank **master_bank)
  37 {
  38         *master_bank = get_flash_bank_by_name_noprobe(bank->name);
  39         if (*master_bank == NULL) {
  40                 LOG_ERROR("master flash bank '%s' does not exist",
  41                         (char *)bank->driver_priv);
  42                 return ERROR_FLASH_OPERATION_FAILED;
  43         }
  44
  45         return ERROR_OK;
  46 }
  47
  48 static int kinetis_update_bank_info(struct flash_bank *bank)
  49 {
  50         int result;
  51         struct flash_bank *master_bank;
  52
  53         result = kinetis_get_master_bank(bank, &master_bank);
  54
  55         if (result != ERROR_OK)
  56                 return result;
  57
  58         /* update the info we do not have */
  59         bank->size = master_bank->size;
  60         bank->chip_width = master_bank->chip_width;
  61         bank->bus_width = master_bank->bus_width;
  62         bank->num_sectors = master_bank->num_sectors;
  63         bank->sectors = master_bank->sectors;
  64
  65         return ERROR_OK;
  66 }
  67
  68 FLASH_BANK_COMMAND_HANDLER(kinetis_flash_bank_command)
  69 {
  70         struct kinetis_flash_bank *bank_info;
  71
  72         if (CMD_ARGC < 6)
  73                 return ERROR_COMMAND_SYNTAX_ERROR;
  74
  75         LOG_INFO("add flash_bank kinetis %s", bank->name);
  76
  77         bank_info = malloc(sizeof(struct kinetis_flash_bank));
  78
  79         memset(bank_info, 0, sizeof(struct kinetis_flash_bank));
  80
  81         bank->driver_priv = bank_info;
  82
  83         return ERROR_OK;
  84 }
  85
  86 static int kinetis_protect(struct flash_bank *bank, int set, int first,
  87         int last)
  88 {
  89         int result;
  90         struct flash_bank *master_bank;
  91
  92         result = kinetis_get_master_bank(bank, &master_bank);
  93
  94         if (result != ERROR_OK)
  95                 return result;
  96
  97         LOG_WARNING("kinetis_protect not supported yet");
  98
  99         if (bank->target->state != TARGET_HALTED) {
 100                 LOG_ERROR("Target not halted");
 101                 return ERROR_TARGET_NOT_HALTED;
 102         }
 103
 104         return ERROR_OK;
 105 }
 106
 107 static int kinetis_protect_check(struct flash_bank *bank)
 108 {
 109         int result;
 110         struct flash_bank *master_bank;
 111         uint8_t buffer[4];
 112         uint32_t fprot, psize, psec;
 113         int i, b;
 114
 115         if (bank->target->state != TARGET_HALTED) {
 116                 LOG_ERROR("Target not halted");
 117                 return ERROR_TARGET_NOT_HALTED;
 118         }
 119
 120         result = kinetis_get_master_bank(bank, &master_bank);
 121
 122         if (result != ERROR_OK)
 123                 return result;
 124
 125         /* read protection register FTFL_FPROT */
 126         result = target_read_memory(bank->target, 0x40020010, 1, 4, buffer);
 127
 128         if (result != ERROR_OK)
 129                 return result;
 130
 131         fprot = target_buffer_get_u32(bank->target, buffer);
 132
 133         /* every bit protect 1/32 of the full flash */
 134         psize = bank->size / 32;
 135         psec = 0;
 136         b = 0;
 137
 138         for (i = 0; i < bank->num_sectors; i++) {
 139                 if ((fprot >> b) & 1)
 140                         bank->sectors[i].is_protected = 0;
 141                 else
 142                         bank->sectors[i].is_protected = 1;
 143
 144                 psec += bank->sectors[i].size;
 145
 146                 if (psec >= psize) {
 147                         psec = 0;
 148                         b++;
 149                 }
 150         }
 151
 152         return ERROR_OK;
 153 }
 154
 155 static int kinetis_ftfl_command(struct flash_bank *bank, uint32_t w0,
 156         uint32_t w1, uint32_t w2)
 157 {
 158         uint8_t buffer[12];
 159         int result, i;
 160
 161         /* wait for done */
 162         for (i = 0; i < 50; i++) {
 163                 result =
 164                         target_read_memory(bank->target, 0x40020000, 1, 1, buffer);
 165
 166                 if (result != ERROR_OK)
 167                         return result;
 168
 169                 if (buffer[0] & 0x80)
 170                         break;
 171
 172                 buffer[0] = 0x00;
 173         }
 174
 175         if (buffer[0] != 0x80) {
 176                 /* reset error flags */
 177                 buffer[0] = 0x30;
 178                 result =
 179                         target_write_memory(bank->target, 0x40020000, 1, 1, buffer);
 180                 if (result != ERROR_OK)
 181                         return result;
 182         }
 183
 184         target_buffer_set_u32(bank->target, buffer, w0);
 185         target_buffer_set_u32(bank->target, buffer + 4, w1);
 186         target_buffer_set_u32(bank->target, buffer + 8, w2);
 187
 188         result = target_write_memory(bank->target, 0x40020004, 4, 3, buffer);
 189
 190         if (result != ERROR_OK)
 191                 return result;
 192
 193         /* start command */
 194         buffer[0] = 0x80;
 195         result = target_write_memory(bank->target, 0x40020000, 1, 1, buffer);
 196         if (result != ERROR_OK)
 197                 return result;
 198
 199         /* wait for done */
 200         for (i = 0; i < 50; i++) {
 201                 result =
 202                         target_read_memory(bank->target, 0x40020000, 1, 1, buffer);
 203
 204                 if (result != ERROR_OK)
 205                         return result;
 206
 207                 if (buffer[0] & 0x80)
 208                         break;
 209
 210                 buffer[0] = 0x00;
 211         }
 212
 213         if (buffer[0] != 0x80) {
 214                 LOG_ERROR
 215                         ("ftfl command failed FSTAT: %02X W0: %08X W1: %08X W2: %08X",
 216                         buffer[0], w0, w1, w2);
 217
 218                 return ERROR_FLASH_OPERATION_FAILED;
 219         }
 220
 221         return ERROR_OK;
 222 }
 223
 224 static int kinetis_erase(struct flash_bank *bank, int first, int last)
 225 {
 226         struct flash_bank *master_bank;
 227         int result, i;
 228         uint32_t w0 = 0, w1 = 0, w2 = 0;
 229
 230         if (bank->target->state != TARGET_HALTED) {
 231                 LOG_ERROR("Target not halted");
 232                 return ERROR_TARGET_NOT_HALTED;
 233         }
 234
 235         result = kinetis_get_master_bank(bank, &master_bank);
 236
 237         if (result != ERROR_OK)
 238                 return result;
 239
 240         if ((first > bank->num_sectors) || (last > bank->num_sectors))
 241                 return ERROR_FLASH_OPERATION_FAILED;
 242
 243         for (i = first; i <= last; i++) {
 244                 /* set command and sector address */
 245                 w0 = (0x09 << 24) | bank->sectors[i].offset;
 246
 247                 result = kinetis_ftfl_command(bank, w0, w1, w2);
 248
 249                 if (result != ERROR_OK) {
 250                         LOG_WARNING("erase sector %d failed", i);
 251                         return ERROR_FLASH_OPERATION_FAILED;
 252                 }
 253
 254                 bank->sectors[i].is_erased = 1;
 255         }
 256
 257         if (first == 0) {
 258                 LOG_WARNING
 259                         ("flash configuration field erased, please reset the device");
 260         }
 261
 262         return ERROR_OK;
 263 }
 264
 265 static int kinetis_write(struct flash_bank *bank, uint8_t *buffer,
 266         uint32_t offset, uint32_t count)
 267 {
 268         struct flash_bank *master_bank;
 269         unsigned int i, result, fallback = 0, nvm = 0;
 270         uint8_t buf[8];
 271         uint32_t wc, w0 = 0, w1 = 0, w2 = 0;
 272         struct kinetis_flash_bank *kbank = (struct kinetis_flash_bank *)
 273                 bank->driver_priv;
 274
 275         if (bank->target->state != TARGET_HALTED) {
 276                 LOG_ERROR("Target not halted");
 277                 return ERROR_TARGET_NOT_HALTED;
 278         }
 279
 280         result = kinetis_get_master_bank(bank, &master_bank);
 281
 282         if (result != ERROR_OK)
 283                 return result;
 284
 285         if (offset >= kbank->nvm_start)
 286                 nvm = 1;
 287
 288         if (!nvm && (offset + count) > kbank->nvm_start) {
 289                 /* we could flash this in two goes, but if the segment
 290                    spans across the pflash/nvm boundary, something is probably
 291                    not right.
 292                 */
 293                 LOG_ERROR("Segment spans NVM boundary");
 294                 return ERROR_FLASH_DST_OUT_OF_BANK;
 295         }
 296
 297         if (nvm) {
 298                 LOG_DEBUG("flash write into NVM @%08X", offset);
 299
 300                 /* make flex ram available */
 301                 w0 = (0x81 << 24) | 0x00ff0000;
 302
 303                 result = kinetis_ftfl_command(bank, w0, w1, w2);
 304
 305                 if (result != ERROR_OK)
 306                         return ERROR_FLASH_OPERATION_FAILED;
 307
 308                 /* check if ram ready */
 309                 result = target_read_memory(bank->target, 0x40020001, 1, 1, buf);
 310
 311                 if (result != ERROR_OK)
 312                         return result;
 313
 314                 if (!(buf[0] & (1 << 1))) {
 315                         /* fallback to longword write */
 316                         fallback = 1;
 317
 318                         LOG_WARNING("ram not ready, fallback to slow longword write (FCNFG: %02X)",
 319                                 buf[0]);
 320                 }
 321         } else {
 322                 LOG_DEBUG("flash write into PFLASH @08%X", offset);
 323                 fallback = 1;
 324         }
 325
 326
 327         /* program section command */
 328         if (fallback == 0) {
 329                 for (i = 0; i < count; i += (2 * 1024)) {
 330                         wc = 512;
 331
 332                         if ((count - i) < (2 * 1024)) {
 333                                 wc = count - i;
 334                                 wc /= 4;
 335                         }
 336
 337                         LOG_DEBUG("write section @ %08X with length %d",
 338                                 offset + i, wc * 4);
 339
 340                         /* write data to flexram */
 341                         result =
 342                                 target_write_memory(bank->target, 0x14000000, 4, wc,
 343                                         buffer + i);
 344
 345                         if (result != ERROR_OK) {
 346                                 LOG_ERROR("target_write_memory failed");
 347
 348                                 return result;
 349                         }
 350
 351                         /* execute section command */
 352                         w0 = (0x0b << 24) | (offset + i);
 353                         w1 = (256 << 16);
 354
 355                         result = kinetis_ftfl_command(bank, w0, w1, w2);
 356
 357                         if (result != ERROR_OK)
 358                                 return ERROR_FLASH_OPERATION_FAILED;
 359                 }
 360         }
 361         /* program longword command */
 362         else {
 363                 for (i = 0; i < count; i += 4) {
 364                         LOG_DEBUG("write longword @ %08X", offset + i);
 365
 366                         w0 = (0x06 << 24) | (offset + i);
 367                         w1 = buf_get_u32(buffer + offset + i, 0, 32);
 368
 369                         result = kinetis_ftfl_command(bank, w0, w1, w2);
 370
 371                         if (result != ERROR_OK)
 372                                 return ERROR_FLASH_OPERATION_FAILED;
 373                 }
 374         }
 375
 376         return ERROR_OK;
 377 }
 378
 379 static int kinetis_probe(struct flash_bank *bank)
 380 {
 381         struct flash_bank *master_bank;
 382         int result, i;
 383         uint8_t buf[4];
 384         uint32_t sim_sdid, sim_fcfg1, sim_fcfg2, offset = 0;
 385         uint32_t nvm_size, pf_size, ee_size;
 386
 387         if (bank->target->state != TARGET_HALTED) {
 388                 LOG_ERROR("Target not halted");
 389                 return ERROR_TARGET_NOT_HALTED;
 390         }
 391
 392         result = kinetis_get_master_bank(bank, &master_bank);
 393
 394         if (result != ERROR_OK)
 395                 return result;
 396
 397         result = target_read_memory(bank->target, 0x40048024, 1, 4, buf);
 398         if (result != ERROR_OK)
 399                 return result;
 400         sim_sdid = target_buffer_get_u32(bank->target, buf);
 401         result = target_read_memory(bank->target, 0x4004804c, 1, 4, buf);
 402         if (result != ERROR_OK)
 403                 return result;
 404         sim_fcfg1 = target_buffer_get_u32(bank->target, buf);
 405         result = target_read_memory(bank->target, 0x40048050, 1, 4, buf);
 406         if (result != ERROR_OK)
 407                 return result;
 408         sim_fcfg2 = target_buffer_get_u32(bank->target, buf);
 409
 410         LOG_DEBUG("SDID: %08X FCFG1: %08X FCFG2: %08X", sim_sdid, sim_fcfg1,
 411                 sim_fcfg2);
 412
 413         switch ((sim_fcfg1 >> 28) & 0x0f) {
 414                 case 0x07:
 415                         nvm_size = 128 * 1024;
 416                         break;
 417                 case 0x09:
 418                 case 0x0f:
 419                         nvm_size = 256 * 1024;
 420                         break;
 421                 default:
 422                         nvm_size = 0;
 423                         break;
 424         }
 425
 426         switch ((sim_fcfg1 >> 24) & 0x0f) {
 427                 case 0x07:
 428                         pf_size = 128 * 1024;
 429                         break;
 430                 case 0x09:
 431                         pf_size = 256 * 1024;
 432                         break;
 433                 case 0x0b:
 434                 case 0x0f:
 435                         pf_size = 512 * 1024;
 436                         break;
 437                 default:
 438                         pf_size = 0;
 439                         break;
 440         }
 441
 442         switch ((sim_fcfg1 >> 16) & 0x0f) {
 443                 case 0x02:
 444                         ee_size = 4 * 1024;
 445                         break;
 446                 case 0x03:
 447                         ee_size = 2 * 1024;
 448                         break;
 449                 case 0x04:
 450                         ee_size = 1 * 1024;
 451                         break;
 452                 case 0x05:
 453                         ee_size = 512;
 454                         break;
 455                 case 0x06:
 456                         ee_size = 256;
 457                         break;
 458                 case 0x07:
 459                         ee_size = 128;
 460                         break;
 461                 case 0x08:
 462                         ee_size = 64;
 463                         break;
 464                 case 0x09:
 465                         ee_size = 32;
 466                         break;
 467                 default:
 468                         ee_size = 0;
 469                         break;
 470         }
 471
 472         ((struct kinetis_flash_bank *) bank->driver_priv)->nvm_start =
 473                 pf_size - nvm_size;
 474
 475         LOG_DEBUG("NVM: %d PF: %d EE: %d BL1: %d", nvm_size, pf_size, ee_size,
 476                 (sim_fcfg2 >> 23) & 1);
 477
 478         if (pf_size != bank->size) {
 479                 LOG_WARNING("flash size is different %d != %d", pf_size,
 480                         bank->size);
 481         }
 482
 483         bank->num_sectors = bank->size / (2 * 1024);
 484         assert(bank->num_sectors > 0);
 485         bank->sectors = malloc(sizeof(struct flash_sector) * bank->num_sectors);
 486
 487         for (i = 0; i < bank->num_sectors; i++) {
 488                 bank->sectors[i].offset = offset;
 489                 bank->sectors[i].size = 2 * 1024;
 490                 offset += bank->sectors[i].size;
 491                 bank->sectors[i].is_erased = -1;
 492                 bank->sectors[i].is_protected = 1;
 493         }
 494
 495         /* update the info we do not have */
 496         return kinetis_update_bank_info(bank);
 497 }
 498
 499 static int kinetis_auto_probe(struct flash_bank *bank)
 500 {
 501         return kinetis_probe(bank);
 502 }
 503
 504 static int kinetis_info(struct flash_bank *bank, char *buf, int buf_size)
 505 {
 506         int result;
 507         struct flash_bank *master_bank;
 508
 509         result = kinetis_get_master_bank(bank, &master_bank);
 510
 511         if (result != ERROR_OK)
 512                 return result;
 513
 514         snprintf(buf, buf_size,
 515                 "%s driver for flash bank %s at 0x%8.8" PRIx32 "",
 516                 bank->driver->name, master_bank->name, master_bank->base);
 517
 518         return ERROR_OK;
 519 }
 520
 521 static int kinetis_blank_check(struct flash_bank *bank)
 522 {
 523         int result;
 524         struct flash_bank *master_bank;
 525
 526         LOG_WARNING("kinetis_blank_check not supported yet");
 527
 528         if (bank->target->state != TARGET_HALTED) {
 529                 LOG_ERROR("Target not halted");
 530                 return ERROR_TARGET_NOT_HALTED;
 531         }
 532
 533         result = kinetis_get_master_bank(bank, &master_bank);
 534
 535         if (result != ERROR_OK)
 536                 return result;
 537
 538         return ERROR_OK;
 539 }
 540
 541 static int kinetis_flash_read(struct flash_bank *bank,
 542         uint8_t *buffer, uint32_t offset, uint32_t count)
 543 {
 544         int result;
 545         struct flash_bank *master_bank;
 546
 547         LOG_WARNING("kinetis_flash_read not supported yet");
 548
 549         if (bank->target->state != TARGET_HALTED) {
 550                 LOG_ERROR("Target not halted");
 551                 return ERROR_TARGET_NOT_HALTED;
 552         }
 553
 554         result = kinetis_get_master_bank(bank, &master_bank);
 555
 556         if (result != ERROR_OK)
 557                 return result;
 558
 559         return ERROR_OK;
 560 }
 561
 562 struct flash_driver kinetis_flash = {
 563         .name = "kinetis",
 564         .flash_bank_command = kinetis_flash_bank_command,
 565         .erase = kinetis_erase,
 566         .protect = kinetis_protect,
 567         .write = kinetis_write,
 568         .read = kinetis_flash_read,
 569         .probe = kinetis_probe,
 570         .auto_probe = kinetis_auto_probe,
 571         .erase_check = kinetis_blank_check,
 572         .protect_check = kinetis_protect_check,
 573         .info = kinetis_info,
 574 };