src/flash/flash.c

   1 /***************************************************************************
   2  *   Copyright (C) 2005 by Dominic Rath                                    *
   3  *   Dominic.Rath@gmx.de                                                   *
   4  *                                                                         *
   5  *   Copyright (C) 2007,2008 Øyvind Harboe                                 *
   6  *   oyvind.harboe@zylin.com                                               *
   7  *                                                                         *
   8  *   Copyright (C) 2008 by Spencer Oliver                                  *
   9  *   spen@spen-soft.co.uk                                                  *
  10  *                                                                         *
  11  *   This program is free software; you can redistribute it and/or modify  *
  12  *   it under the terms of the GNU General Public License as published by  *
  13  *   the Free Software Foundation; either version 2 of the License, or     *
  14  *   (at your option) any later version.                                   *
  15  *                                                                         *
  16  *   This program is distributed in the hope that it will be useful,       *
  17  *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
  18  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         *
  19  *   GNU General Public License for more details.                          *
  20  *                                                                         *
  21  *   You should have received a copy of the GNU General Public License     *
  22  *   along with this program; if not, write to the                         *
  23  *   Free Software Foundation, Inc.,                                       *
  24  *   59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.             *
  25  ***************************************************************************/
  26 #ifdef HAVE_CONFIG_H
  27 #include "config.h"
  28 #endif
  29
  30 #include "flash.h"
  31 #include "common.h"
  32 #include <target/image.h>
  33 #include <helper/time_support.h>
  34
  35 /* flash drivers
  36  */
  37 extern struct flash_driver lpc2000_flash;
  38 extern struct flash_driver lpc288x_flash;
  39 extern struct flash_driver lpc2900_flash;
  40 extern struct flash_driver cfi_flash;
  41 extern struct flash_driver at91sam3_flash;
  42 extern struct flash_driver at91sam7_flash;
  43 extern struct flash_driver str7x_flash;
  44 extern struct flash_driver str9x_flash;
  45 extern struct flash_driver aduc702x_flash;
  46 extern struct flash_driver stellaris_flash;
  47 extern struct flash_driver str9xpec_flash;
  48 extern struct flash_driver stm32x_flash;
  49 extern struct flash_driver tms470_flash;
  50 extern struct flash_driver ecosflash_flash;
  51 extern struct flash_driver ocl_flash;
  52 extern struct flash_driver pic32mx_flash;
  53 extern struct flash_driver avr_flash;
  54 extern struct flash_driver faux_flash;
  55
  56 struct flash_driver *flash_drivers[] = {
  57         &lpc2000_flash,
  58         &lpc288x_flash,
  59         &lpc2900_flash,
  60         &cfi_flash,
  61         &at91sam7_flash,
  62         &at91sam3_flash,
  63         &str7x_flash,
  64         &str9x_flash,
  65         &aduc702x_flash,
  66         &stellaris_flash,
  67         &str9xpec_flash,
  68         &stm32x_flash,
  69         &tms470_flash,
  70         &ecosflash_flash,
  71         &ocl_flash,
  72         &pic32mx_flash,
  73         &avr_flash,
  74         &faux_flash,
  75         NULL,
  76 };
  77
  78 struct flash_bank *flash_banks;
  79
  80 struct flash_bank *get_flash_bank_by_num_noprobe(int num)
  81 {
  82         struct flash_bank *p;
  83         int i = 0;
  84
  85         for (p = flash_banks; p; p = p->next)
  86         {
  87                 if (i++ == num)
  88                 {
  89                         return p;
  90                 }
  91         }
  92         LOG_ERROR("flash bank %d does not exist", num);
  93         return NULL;
  94 }
  95
  96 int flash_get_bank_count(void)
  97 {
  98         struct flash_bank *p;
  99         int i = 0;
 100         for (p = flash_banks; p; p = p->next)
 101         {
 102                 i++;
 103         }
 104         return i;
 105 }
 106
 107 struct flash_bank *get_flash_bank_by_name(const char *name)
 108 {
 109         unsigned requested = get_flash_name_index(name);
 110         unsigned found = 0;
 111
 112         struct flash_bank *bank;
 113         for (bank = flash_banks; NULL != bank; bank = bank->next)
 114         {
 115                 if (strcmp(bank->name, name) == 0)
 116                         return bank;
 117                 if (!flash_driver_name_matches(bank->driver->name, name))
 118                         continue;
 119                 if (++found < requested)
 120                         continue;
 121                 return bank;
 122         }
 123         return NULL;
 124 }
 125
 126 struct flash_bank *get_flash_bank_by_num(int num)
 127 {
 128         struct flash_bank *p = get_flash_bank_by_num_noprobe(num);
 129         int retval;
 130
 131         if (p == NULL)
 132                 return NULL;
 133
 134         retval = p->driver->auto_probe(p);
 135
 136         if (retval != ERROR_OK)
 137         {
 138                 LOG_ERROR("auto_probe failed %d\n", retval);
 139                 return NULL;
 140         }
 141         return p;
 142 }
 143
 144 /* lookup flash bank by address */
 145 struct flash_bank *get_flash_bank_by_addr(struct target *target, uint32_t addr)
 146 {
 147         struct flash_bank *c;
 148
 149         /* cycle through bank list */
 150         for (c = flash_banks; c; c = c->next)
 151         {
 152                 int retval;
 153                 retval = c->driver->auto_probe(c);
 154
 155                 if (retval != ERROR_OK)
 156                 {
 157                         LOG_ERROR("auto_probe failed %d\n", retval);
 158                         return NULL;
 159                 }
 160                 /* check whether address belongs to this flash bank */
 161                 if ((addr >= c->base) && (addr <= c->base + (c->size - 1)) && target == c->target)
 162                         return c;
 163         }
 164         LOG_ERROR("No flash at address 0x%08" PRIx32 "\n", addr);
 165         return NULL;
 166 }
 167
 168 int default_flash_mem_blank_check(struct flash_bank *bank)
 169 {
 170         struct target *target = bank->target;
 171         const int buffer_size = 1024;
 172         int i;
 173         uint32_t nBytes;
 174         int retval = ERROR_OK;
 175
 176         if (bank->target->state != TARGET_HALTED)
 177         {
 178                 LOG_ERROR("Target not halted");
 179                 return ERROR_TARGET_NOT_HALTED;
 180         }
 181
 182         uint8_t *buffer = malloc(buffer_size);
 183
 184         for (i = 0; i < bank->num_sectors; i++)
 185         {
 186                 uint32_t j;
 187                 bank->sectors[i].is_erased = 1;
 188
 189                 for (j = 0; j < bank->sectors[i].size; j += buffer_size)
 190                 {
 191                         uint32_t chunk;
 192                         chunk = buffer_size;
 193                         if (chunk > (j - bank->sectors[i].size))
 194                         {
 195                                 chunk = (j - bank->sectors[i].size);
 196                         }
 197
 198                         retval = target_read_memory(target, bank->base + bank->sectors[i].offset + j, 4, chunk/4, buffer);
 199                         if (retval != ERROR_OK)
 200                         {
 201                                 goto done;
 202                         }
 203
 204                         for (nBytes = 0; nBytes < chunk; nBytes++)
 205                         {
 206                                 if (buffer[nBytes] != 0xFF)
 207                                 {
 208                                         bank->sectors[i].is_erased = 0;
 209                                         break;
 210                                 }
 211                         }
 212                 }
 213         }
 214
 215         done:
 216         free(buffer);
 217
 218         return retval;
 219 }
 220
 221 int default_flash_blank_check(struct flash_bank *bank)
 222 {
 223         struct target *target = bank->target;
 224         int i;
 225         int retval;
 226         int fast_check = 0;
 227         uint32_t blank;
 228
 229         if (bank->target->state != TARGET_HALTED)
 230         {
 231                 LOG_ERROR("Target not halted");
 232                 return ERROR_TARGET_NOT_HALTED;
 233         }
 234
 235         for (i = 0; i < bank->num_sectors; i++)
 236         {
 237                 uint32_t address = bank->base + bank->sectors[i].offset;
 238                 uint32_t size = bank->sectors[i].size;
 239
 240                 if ((retval = target_blank_check_memory(target, address, size, &blank)) != ERROR_OK)
 241                 {
 242                         fast_check = 0;
 243                         break;
 244                 }
 245                 if (blank == 0xFF)
 246                         bank->sectors[i].is_erased = 1;
 247                 else
 248                         bank->sectors[i].is_erased = 0;
 249                 fast_check = 1;
 250         }
 251
 252         if (!fast_check)
 253         {
 254                 LOG_USER("Running slow fallback erase check - add working memory");
 255                 return default_flash_mem_blank_check(bank);
 256         }
 257
 258         return ERROR_OK;
 259 }