src/flash/nor/jtagspi.c

   1 /***************************************************************************
   2  *   Copyright (C) 2015 Robert Jordens <jordens@gmail.com>                 *
   3  *                                                                         *
   4  *   This program is free software; you can redistribute it and/or modify  *
   5  *   it under the terms of the GNU General Public License as published by  *
   6  *   the Free Software Foundation; either version 2 of the License, or     *
   7  *   (at your option) any later version.                                   *
   8  *                                                                         *
   9  *   This program is distributed in the hope that it will be useful,       *
  10  *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
  11  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         *
  12  *   GNU General Public License for more details.                          *
  13  *                                                                         *
  14  *   You should have received a copy of the GNU General Public License     *
  15  *   along with this program.  If not, see <http://www.gnu.org/licenses/>. *
  16  ***************************************************************************/
  17
  18 #ifdef HAVE_CONFIG_H
  19 #include "config.h"
  20 #endif
  21
  22 #include "imp.h"
  23 #include <jtag/jtag.h>
  24 #include <flash/nor/spi.h>
  25 #include <helper/time_support.h>
  26
  27 #define JTAGSPI_MAX_TIMEOUT 3000
  28
  29
  30 struct jtagspi_flash_bank {
  31         struct jtag_tap *tap;
  32         const struct flash_device *dev;
  33         int probed;
  34         uint32_t ir;
  35 };
  36
  37 FLASH_BANK_COMMAND_HANDLER(jtagspi_flash_bank_command)
  38 {
  39         struct jtagspi_flash_bank *info;
  40
  41         if (CMD_ARGC < 7)
  42                 return ERROR_COMMAND_SYNTAX_ERROR;
  43
  44         info = malloc(sizeof(struct jtagspi_flash_bank));
  45         if (info == NULL) {
  46                 LOG_ERROR("no memory for flash bank info");
  47                 return ERROR_FAIL;
  48         }
  49         bank->driver_priv = info;
  50
  51         info->tap = NULL;
  52         info->probed = 0;
  53         COMMAND_PARSE_NUMBER(u32, CMD_ARGV[6], info->ir);
  54
  55         return ERROR_OK;
  56 }
  57
  58 static void jtagspi_set_ir(struct flash_bank *bank)
  59 {
  60         struct jtagspi_flash_bank *info = bank->driver_priv;
  61         struct scan_field field;
  62         uint8_t buf[4];
  63
  64         LOG_DEBUG("loading jtagspi ir");
  65         buf_set_u32(buf, 0, info->tap->ir_length, info->ir);
  66         field.num_bits = info->tap->ir_length;
  67         field.out_value = buf;
  68         field.in_value = NULL;
  69         jtag_add_ir_scan(info->tap, &field, TAP_IDLE);
  70 }
  71
  72 static void flip_u8(uint8_t *in, uint8_t *out, int len)
  73 {
  74         for (int i = 0; i < len; i++)
  75                 out[i] = flip_u32(in[i], 8);
  76 }
  77
  78 static int jtagspi_cmd(struct flash_bank *bank, uint8_t cmd,
  79                 uint32_t *addr, uint8_t *data, int len)
  80 {
  81         struct jtagspi_flash_bank *info = bank->driver_priv;
  82         struct scan_field fields[6];
  83         uint8_t marker = 1;
  84         uint8_t xfer_bits_buf[4];
  85         uint8_t addr_buf[3];
  86         uint8_t *data_buf;
  87         uint32_t xfer_bits;
  88         int is_read, lenb, n;
  89
  90         /* LOG_DEBUG("cmd=0x%02x len=%i", cmd, len); */
  91
  92         is_read = (len < 0);
  93         if (is_read)
  94                 len = -len;
  95
  96         n = 0;
  97
  98         fields[n].num_bits = 1;
  99         fields[n].out_value = &marker;
 100         fields[n].in_value = NULL;
 101         n++;
 102
 103         xfer_bits = 8 + len - 1;
 104         /* cmd + read/write - 1 due to the counter implementation */
 105         if (addr)
 106                 xfer_bits += 24;
 107         h_u32_to_be(xfer_bits_buf, xfer_bits);
 108         flip_u8(xfer_bits_buf, xfer_bits_buf, 4);
 109         fields[n].num_bits = 32;
 110         fields[n].out_value = xfer_bits_buf;
 111         fields[n].in_value = NULL;
 112         n++;
 113
 114         cmd = flip_u32(cmd, 8);
 115         fields[n].num_bits = 8;
 116         fields[n].out_value = &cmd;
 117         fields[n].in_value = NULL;
 118         n++;
 119
 120         if (addr) {
 121                 h_u24_to_be(addr_buf, *addr);
 122                 flip_u8(addr_buf, addr_buf, 3);
 123                 fields[n].num_bits = 24;
 124                 fields[n].out_value = addr_buf;
 125                 fields[n].in_value = NULL;
 126                 n++;
 127         }
 128
 129         lenb = DIV_ROUND_UP(len, 8);
 130         data_buf = malloc(lenb);
 131         if (lenb > 0) {
 132                 if (data_buf == NULL) {
 133                         LOG_ERROR("no memory for spi buffer");
 134                         return ERROR_FAIL;
 135                 }
 136                 if (is_read) {
 137                         fields[n].num_bits = jtag_tap_count_enabled();
 138                         fields[n].out_value = NULL;
 139                         fields[n].in_value = NULL;
 140                         n++;
 141
 142                         fields[n].out_value = NULL;
 143                         fields[n].in_value = data_buf;
 144                 } else {
 145                         flip_u8(data, data_buf, lenb);
 146                         fields[n].out_value = data_buf;
 147                         fields[n].in_value = NULL;
 148                 }
 149                 fields[n].num_bits = len;
 150                 n++;
 151         }
 152
 153         jtagspi_set_ir(bank);
 154         /* passing from an IR scan to SHIFT-DR clears BYPASS registers */
 155         jtag_add_dr_scan(info->tap, n, fields, TAP_IDLE);
 156         jtag_execute_queue();
 157
 158         if (is_read)
 159                 flip_u8(data_buf, data, lenb);
 160         free(data_buf);
 161         return ERROR_OK;
 162 }
 163
 164 static int jtagspi_probe(struct flash_bank *bank)
 165 {
 166         struct jtagspi_flash_bank *info = bank->driver_priv;
 167         struct flash_sector *sectors;
 168         uint8_t in_buf[3];
 169         uint32_t id;
 170
 171         if (info->probed)
 172                 free(bank->sectors);
 173         info->probed = 0;
 174
 175         if (bank->target->tap == NULL) {
 176                 LOG_ERROR("Target has no JTAG tap");
 177                 return ERROR_FAIL;
 178         }
 179         info->tap = bank->target->tap;
 180
 181         jtagspi_cmd(bank, SPIFLASH_READ_ID, NULL, in_buf, -24);
 182         /* the table in spi.c has the manufacturer byte (first) as the lsb */
 183         id = le_to_h_u24(in_buf);
 184
 185         info->dev = NULL;
 186         for (const struct flash_device *p = flash_devices; p->name ; p++)
 187                 if (p->device_id == id) {
 188                         info->dev = p;
 189                         break;
 190                 }
 191
 192         if (!(info->dev)) {
 193                 LOG_ERROR("Unknown flash device (ID 0x%08" PRIx32 ")", id);
 194                 return ERROR_FAIL;
 195         }
 196
 197         LOG_INFO("Found flash device \'%s\' (ID 0x%08" PRIx32 ")",
 198                 info->dev->name, info->dev->device_id);
 199
 200         /* Set correct size value */
 201         bank->size = info->dev->size_in_bytes;
 202
 203         /* create and fill sectors array */
 204         bank->num_sectors =
 205                 info->dev->size_in_bytes / info->dev->sectorsize;
 206         sectors = malloc(sizeof(struct flash_sector) * bank->num_sectors);
 207         if (sectors == NULL) {
 208                 LOG_ERROR("not enough memory");
 209                 return ERROR_FAIL;
 210         }
 211
 212         for (int sector = 0; sector < bank->num_sectors; sector++) {
 213                 sectors[sector].offset = sector * info->dev->sectorsize;
 214                 sectors[sector].size = info->dev->sectorsize;
 215                 sectors[sector].is_erased = -1;
 216                 sectors[sector].is_protected = 0;
 217         }
 218
 219         bank->sectors = sectors;
 220         info->probed = 1;
 221         return ERROR_OK;
 222 }
 223
 224 static void jtagspi_read_status(struct flash_bank *bank, uint32_t *status)
 225 {
 226         uint8_t buf;
 227         if (jtagspi_cmd(bank, SPIFLASH_READ_STATUS, NULL, &buf, -8) == ERROR_OK) {
 228                 *status = buf;
 229                 /* LOG_DEBUG("status=0x%08" PRIx32, *status); */
 230         }
 231 }
 232
 233 static int jtagspi_wait(struct flash_bank *bank, int timeout_ms)
 234 {
 235         uint32_t status;
 236         int64_t t0 = timeval_ms();
 237         int64_t dt;
 238
 239         do {
 240                 dt = timeval_ms() - t0;
 241                 jtagspi_read_status(bank, &status);
 242                 if ((status & SPIFLASH_BSY_BIT) == 0) {
 243                         LOG_DEBUG("waited %" PRId64 " ms", dt);
 244                         return ERROR_OK;
 245                 }
 246                 alive_sleep(1);
 247         } while (dt <= timeout_ms);
 248
 249         LOG_ERROR("timeout, device still busy");
 250         return ERROR_FAIL;
 251 }
 252
 253 static int jtagspi_write_enable(struct flash_bank *bank)
 254 {
 255         uint32_t status;
 256
 257         jtagspi_cmd(bank, SPIFLASH_WRITE_ENABLE, NULL, NULL, 0);
 258         jtagspi_read_status(bank, &status);
 259         if ((status & SPIFLASH_WE_BIT) == 0) {
 260                 LOG_ERROR("Cannot enable write to flash. Status=0x%08" PRIx32, status);
 261                 return ERROR_FAIL;
 262         }
 263         return ERROR_OK;
 264 }
 265
 266 static int jtagspi_bulk_erase(struct flash_bank *bank)
 267 {
 268         struct jtagspi_flash_bank *info = bank->driver_priv;
 269         int retval;
 270         int64_t t0 = timeval_ms();
 271
 272         retval = jtagspi_write_enable(bank);
 273         if (retval != ERROR_OK)
 274                 return retval;
 275         jtagspi_cmd(bank, info->dev->chip_erase_cmd, NULL, NULL, 0);
 276         retval = jtagspi_wait(bank, bank->num_sectors*JTAGSPI_MAX_TIMEOUT);
 277         LOG_INFO("took %" PRId64 " ms", timeval_ms() - t0);
 278         return retval;
 279 }
 280
 281 static int jtagspi_sector_erase(struct flash_bank *bank, int sector)
 282 {
 283         struct jtagspi_flash_bank *info = bank->driver_priv;
 284         int retval;
 285         int64_t t0 = timeval_ms();
 286
 287         retval = jtagspi_write_enable(bank);
 288         if (retval != ERROR_OK)
 289                 return retval;
 290         jtagspi_cmd(bank, info->dev->erase_cmd, &bank->sectors[sector].offset, NULL, 0);
 291         retval = jtagspi_wait(bank, JTAGSPI_MAX_TIMEOUT);
 292         LOG_INFO("sector %d took %" PRId64 " ms", sector, timeval_ms() - t0);
 293         return retval;
 294 }
 295
 296 static int jtagspi_erase(struct flash_bank *bank, int first, int last)
 297 {
 298         int sector;
 299         struct jtagspi_flash_bank *info = bank->driver_priv;
 300         int retval = ERROR_OK;
 301
 302         LOG_DEBUG("erase from sector %d to sector %d", first, last);
 303
 304         if ((first < 0) || (last < first) || (last >= bank->num_sectors)) {
 305                 LOG_ERROR("Flash sector invalid");
 306                 return ERROR_FLASH_SECTOR_INVALID;
 307         }
 308
 309         if (!(info->probed)) {
 310                 LOG_ERROR("Flash bank not probed");
 311                 return ERROR_FLASH_BANK_NOT_PROBED;
 312         }
 313
 314         for (sector = first; sector <= last; sector++) {
 315                 if (bank->sectors[sector].is_protected) {
 316                         LOG_ERROR("Flash sector %d protected", sector);
 317                         return ERROR_FAIL;
 318                 }
 319         }
 320
 321         if (first == 0 && last == (bank->num_sectors - 1)
 322                 && info->dev->chip_erase_cmd != info->dev->erase_cmd) {
 323                 LOG_DEBUG("Trying bulk erase.");
 324                 retval = jtagspi_bulk_erase(bank);
 325                 if (retval == ERROR_OK)
 326                         return retval;
 327                 else
 328                         LOG_WARNING("Bulk flash erase failed. Falling back to sector erase.");
 329         }
 330
 331         for (sector = first; sector <= last; sector++) {
 332                 retval = jtagspi_sector_erase(bank, sector);
 333                 if (retval != ERROR_OK) {
 334                         LOG_ERROR("Sector erase failed.");
 335                         break;
 336                 }
 337         }
 338
 339         return retval;
 340 }
 341
 342 static int jtagspi_protect(struct flash_bank *bank, int set, int first, int last)
 343 {
 344         int sector;
 345
 346         for (sector = first; sector <= last; sector++)
 347                 bank->sectors[sector].is_protected = set;
 348         return ERROR_OK;
 349 }
 350
 351 static int jtagspi_read(struct flash_bank *bank, uint8_t *buffer, uint32_t offset, uint32_t count)
 352 {
 353         struct jtagspi_flash_bank *info = bank->driver_priv;
 354
 355         if (!(info->probed)) {
 356                 LOG_ERROR("Flash bank not yet probed.");
 357                 return ERROR_FLASH_BANK_NOT_PROBED;
 358         }
 359
 360         jtagspi_cmd(bank, SPIFLASH_READ, &offset, buffer, -count*8);
 361         return ERROR_OK;
 362 }
 363
 364 static int jtagspi_page_write(struct flash_bank *bank, const uint8_t *buffer, uint32_t offset, uint32_t count)
 365 {
 366         int retval;
 367
 368         retval = jtagspi_write_enable(bank);
 369         if (retval != ERROR_OK)
 370                 return retval;
 371         jtagspi_cmd(bank, SPIFLASH_PAGE_PROGRAM, &offset, (uint8_t *) buffer, count*8);
 372         return jtagspi_wait(bank, JTAGSPI_MAX_TIMEOUT);
 373 }
 374
 375 static int jtagspi_write(struct flash_bank *bank, const uint8_t *buffer, uint32_t offset, uint32_t count)
 376 {
 377         struct jtagspi_flash_bank *info = bank->driver_priv;
 378         int retval;
 379         uint32_t n;
 380
 381         if (!(info->probed)) {
 382                 LOG_ERROR("Flash bank not yet probed.");
 383                 return ERROR_FLASH_BANK_NOT_PROBED;
 384         }
 385
 386         for (n = 0; n < count; n += info->dev->pagesize) {
 387                 retval = jtagspi_page_write(bank, buffer + n, offset + n,
 388                                 MIN(count - n, info->dev->pagesize));
 389                 if (retval != ERROR_OK) {
 390                         LOG_ERROR("page write error");
 391                         return retval;
 392                 }
 393                 LOG_DEBUG("wrote page at 0x%08" PRIx32, offset + n);
 394         }
 395         return ERROR_OK;
 396 }
 397
 398 static int jtagspi_info(struct flash_bank *bank, char *buf, int buf_size)
 399 {
 400         struct jtagspi_flash_bank *info = bank->driver_priv;
 401
 402         if (!(info->probed)) {
 403                 snprintf(buf, buf_size, "\nJTAGSPI flash bank not probed yet\n");
 404                 return ERROR_OK;
 405         }
 406
 407         snprintf(buf, buf_size, "\nSPIFI flash information:\n"
 408                 "  Device \'%s\' (ID 0x%08" PRIx32 ")\n",
 409                 info->dev->name, info->dev->device_id);
 410
 411         return ERROR_OK;
 412 }
 413
 414 struct flash_driver jtagspi_flash = {
 415         .name = "jtagspi",
 416         .flash_bank_command = jtagspi_flash_bank_command,
 417         .erase = jtagspi_erase,
 418         .protect = jtagspi_protect,
 419         .write = jtagspi_write,
 420         .read = jtagspi_read,
 421         .probe = jtagspi_probe,
 422         .auto_probe = jtagspi_probe,
 423         .erase_check = default_flash_blank_check,
 424         .info = jtagspi_info,
 425         .free_driver_priv = default_flash_free_driver_priv,
 426 };