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