arch/x86/lib/mrccache.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 /*
   3  * From coreboot src/southbridge/intel/bd82x6x/mrccache.c
   4  *
   5  * Copyright (C) 2014 Google Inc.
   6  * Copyright (C) 2015 Bin Meng <bmeng.cn@gmail.com>
   7  */
   8
   9 #define LOG_CATEGORY    UCLASS_RAM
  10
  11 #include <common.h>
  12 #include <dm.h>
  13 #include <errno.h>
  14 #include <fdtdec.h>
  15 #include <log.h>
  16 #include <malloc.h>
  17 #include <net.h>
  18 #include <spi.h>
  19 #include <spi_flash.h>
  20 #include <asm/global_data.h>
  21 #include <asm/mrccache.h>
  22 #include <dm/device-internal.h>
  23 #include <dm/uclass-internal.h>
  24
  25 DECLARE_GLOBAL_DATA_PTR;
  26
  27 static uint mrc_block_size(uint data_size)
  28 {
  29         uint mrc_size = sizeof(struct mrc_data_container) + data_size;
  30
  31         return ALIGN(mrc_size, MRC_DATA_ALIGN);
  32 }
  33
  34 static struct mrc_data_container *next_mrc_block(
  35         struct mrc_data_container *cache)
  36 {
  37         /* MRC data blocks are aligned within the region */
  38         u8 *region_ptr = (u8 *)cache;
  39
  40         region_ptr += mrc_block_size(cache->data_size);
  41
  42         return (struct mrc_data_container *)region_ptr;
  43 }
  44
  45 static int is_mrc_cache(struct mrc_data_container *cache)
  46 {
  47         return cache && (cache->signature == MRC_DATA_SIGNATURE);
  48 }
  49
  50 struct mrc_data_container *mrccache_find_current(struct mrc_region *entry)
  51 {
  52         struct mrc_data_container *cache, *next;
  53         ulong base_addr, end_addr;
  54         uint id;
  55
  56         base_addr = entry->base + entry->offset;
  57         end_addr = base_addr + entry->length;
  58         cache = NULL;
  59
  60         /* Search for the last filled entry in the region */
  61         for (id = 0, next = (struct mrc_data_container *)base_addr;
  62              is_mrc_cache(next);
  63              id++) {
  64                 cache = next;
  65                 next = next_mrc_block(next);
  66                 if ((ulong)next >= end_addr)
  67                         break;
  68         }
  69
  70         if (id-- == 0) {
  71                 debug("%s: No valid MRC cache found.\n", __func__);
  72                 return NULL;
  73         }
  74
  75         /* Verify checksum */
  76         if (cache->checksum != compute_ip_checksum(cache->data,
  77                                                    cache->data_size)) {
  78                 printf("%s: MRC cache checksum mismatch\n", __func__);
  79                 return NULL;
  80         }
  81
  82         debug("%s: picked entry %u from cache block\n", __func__, id);
  83
  84         return cache;
  85 }
  86
  87 /**
  88  * find_next_mrc_cache() - get next cache entry
  89  *
  90  * This moves to the next cache entry in the region, making sure it has enough
  91  * space to hold data of size @data_size.
  92  *
  93  * @entry:      MRC cache flash area
  94  * @cache:      Entry to start from
  95  * @data_size:  Required data size of the new entry. Note that we assume that
  96  *      all cache entries are the same size
  97  *
  98  * Return: next cache entry if found, NULL if we got to the end
  99  */
 100 static struct mrc_data_container *find_next_mrc_cache(struct mrc_region *entry,
 101                 struct mrc_data_container *prev, int data_size)
 102 {
 103         struct mrc_data_container *cache;
 104         ulong base_addr, end_addr;
 105
 106         base_addr = entry->base + entry->offset;
 107         end_addr = base_addr + entry->length;
 108
 109         /*
 110          * We assume that all cache entries are the same size, but let's use
 111          * data_size here for clarity.
 112          */
 113         cache = next_mrc_block(prev);
 114         if ((ulong)cache + mrc_block_size(data_size) > end_addr) {
 115                 /* Crossed the boundary */
 116                 cache = NULL;
 117                 debug("%s: no available entries found\n", __func__);
 118         } else {
 119                 debug("%s: picked next entry from cache block at %p\n",
 120                       __func__, cache);
 121         }
 122
 123         return cache;
 124 }
 125
 126 /**
 127  * mrccache_update() - update the MRC cache with a new record
 128  *
 129  * This writes a new record to the end of the MRC cache region. If the new
 130  * record is the same as the latest record then the write is skipped
 131  *
 132  * @sf:         SPI flash to write to
 133  * @entry:      Position and size of MRC cache in SPI flash
 134  * @cur:        Record to write
 135  * Return: 0 if updated, -EEXIST if the record is the same as the latest
 136  * record, -EINVAL if the record is not valid, other error if SPI write failed
 137  */
 138 static int mrccache_update(struct udevice *sf, struct mrc_region *entry,
 139                            struct mrc_data_container *cur)
 140 {
 141         struct mrc_data_container *cache;
 142         ulong offset;
 143         ulong base_addr;
 144         int ret;
 145
 146         if (!is_mrc_cache(cur)) {
 147                 debug("%s: Cache data not valid\n", __func__);
 148                 return -EINVAL;
 149         }
 150
 151         /* Find the last used block */
 152         base_addr = entry->base + entry->offset;
 153         debug("Updating MRC cache data\n");
 154         cache = mrccache_find_current(entry);
 155         if (cache && (cache->data_size == cur->data_size) &&
 156             (!memcmp(cache, cur, cache->data_size + sizeof(*cur)))) {
 157                 debug("MRC data in flash is up to date. No update\n");
 158                 return -EEXIST;
 159         }
 160
 161         /* Move to the next block, which will be the first unused block */
 162         if (cache)
 163                 cache = find_next_mrc_cache(entry, cache, cur->data_size);
 164
 165         /*
 166          * If we have got to the end, erase the entire mrc-cache area and start
 167          * again at block 0.
 168          */
 169         if (!cache) {
 170                 debug("Erasing the MRC cache region of %x bytes at %x\n",
 171                       entry->length, entry->offset);
 172
 173                 ret = spi_flash_erase_dm(sf, entry->offset, entry->length);
 174                 if (ret) {
 175                         debug("Failed to erase flash region\n");
 176                         return ret;
 177                 }
 178                 cache = (struct mrc_data_container *)base_addr;
 179         }
 180
 181         /* Write the data out */
 182         offset = (ulong)cache - base_addr + entry->offset;
 183         debug("Write MRC cache update to flash at %lx\n", offset);
 184         ret = spi_flash_write_dm(sf, offset, cur->data_size + sizeof(*cur),
 185                                  cur);
 186         if (ret) {
 187                 debug("Failed to write to SPI flash\n");
 188                 return log_msg_ret("Cannot update mrccache", ret);
 189         }
 190
 191         return 0;
 192 }
 193
 194 static void mrccache_setup(struct mrc_output *mrc, void *data)
 195 {
 196         struct mrc_data_container *cache = data;
 197         u16 checksum;
 198
 199         cache->signature = MRC_DATA_SIGNATURE;
 200         cache->data_size = mrc->len;
 201         checksum = compute_ip_checksum(mrc->buf, cache->data_size);
 202         log_debug("Saving %d bytes for MRC output data, checksum %04x\n",
 203                   cache->data_size, checksum);
 204         cache->checksum = checksum;
 205         cache->reserved = 0;
 206         memcpy(cache->data, mrc->buf, cache->data_size);
 207
 208         mrc->cache = cache;
 209 }
 210
 211 int mrccache_reserve(void)
 212 {
 213         int i;
 214
 215         for (i = 0; i < MRC_TYPE_COUNT; i++) {
 216                 struct mrc_output *mrc = &gd->arch.mrc[i];
 217
 218                 if (!mrc->len)
 219                         continue;
 220
 221                 /* adjust stack pointer to store pure cache data plus header */
 222                 gd->start_addr_sp -= (mrc->len + MRC_DATA_HEADER_SIZE);
 223                 mrccache_setup(mrc, (void *)gd->start_addr_sp);
 224
 225                 gd->start_addr_sp &= ~0xf;
 226         }
 227
 228         return 0;
 229 }
 230
 231 int mrccache_get_region(enum mrc_type_t type, struct udevice **devp,
 232                         struct mrc_region *entry)
 233 {
 234         struct udevice *dev;
 235         ofnode mrc_node;
 236         ulong map_base;
 237         uint map_size;
 238         uint offset;
 239         ofnode node;
 240         u32 reg[2];
 241         int ret;
 242
 243         /*
 244          * Find the flash chip within the SPI controller node. Avoid probing
 245          * the device here since it may put it into a strange state where the
 246          * memory map cannot be read.
 247          */
 248         ret = uclass_find_first_device(UCLASS_SPI_FLASH, &dev);
 249         if (ret || !dev) {
 250                 /*
 251                  * Fall back to searching the device tree since driver model
 252                  * may not be ready yet (e.g. with FSPv1)
 253                  */
 254                 node = ofnode_by_compatible(ofnode_null(), "jedec,spi-nor");
 255                 if (!ofnode_valid(node))
 256                         return log_msg_ret("Cannot find SPI flash\n", -ENOENT);
 257                 ret = -ENODEV;
 258         } else {
 259                 ret = dm_spi_get_mmap(dev, &map_base, &map_size, &offset);
 260                 if (!ret)
 261                         entry->base = map_base;
 262                 node = dev_ofnode(dev);
 263         }
 264
 265         /*
 266          * At this point we have entry->base if ret == 0. If not, then we have
 267          * the node and can look for memory-map
 268          */
 269         if (ret) {
 270                 ret = ofnode_read_u32_array(node, "memory-map", reg, 2);
 271                 if (ret)
 272                         return log_msg_ret("Cannot find memory map\n", ret);
 273                 entry->base = reg[0];
 274         }
 275
 276         /* Find the place where we put the MRC cache */
 277         mrc_node = ofnode_find_subnode(node, type == MRC_TYPE_NORMAL ?
 278                                        "rw-mrc-cache" : "rw-var-mrc-cache");
 279         if (!ofnode_valid(mrc_node))
 280                 return log_msg_ret("Cannot find node", -EPERM);
 281
 282         ret = ofnode_read_u32_array(mrc_node, "reg", reg, 2);
 283         if (ret)
 284                 return log_msg_ret("Cannot find address", ret);
 285         entry->offset = reg[0];
 286         entry->length = reg[1];
 287
 288         if (devp)
 289                 *devp = dev;
 290         debug("MRC cache type %d in '%s', offset %x, len %x, base %x\n",
 291               type, dev ? dev->name : ofnode_get_name(node), entry->offset,
 292               entry->length, entry->base);
 293
 294         return 0;
 295 }
 296
 297 static int mrccache_save_type(enum mrc_type_t type)
 298 {
 299         struct mrc_data_container *cache;
 300         struct mrc_output *mrc;
 301         struct mrc_region entry;
 302         struct udevice *sf;
 303         int ret;
 304
 305         mrc = &gd->arch.mrc[type];
 306         if (!mrc->len)
 307                 return 0;
 308         log_debug("Saving %x bytes of MRC output data type %d to SPI flash\n",
 309                   mrc->len, type);
 310         ret = mrccache_get_region(type, &sf, &entry);
 311         if (ret)
 312                 return log_msg_ret("Cannot get region", ret);
 313         ret = device_probe(sf);
 314         if (ret)
 315                 return log_msg_ret("Cannot probe device", ret);
 316         cache = mrc->cache;
 317
 318         ret = mrccache_update(sf, &entry, cache);
 319         if (!ret)
 320                 debug("Saved MRC data with checksum %04x\n", cache->checksum);
 321         else if (ret == -EEXIST)
 322                 debug("MRC data is the same as last time, skipping save\n");
 323
 324         return 0;
 325 }
 326
 327 int mrccache_save(void)
 328 {
 329         int i;
 330
 331         for (i = 0; i < MRC_TYPE_COUNT; i++) {
 332                 int ret;
 333
 334                 ret = mrccache_save_type(i);
 335                 if (ret)
 336                         return ret;
 337         }
 338
 339         return 0;
 340 }
 341
 342 int mrccache_spl_save(void)
 343 {
 344         int i;
 345
 346         for (i = 0; i < MRC_TYPE_COUNT; i++) {
 347                 struct mrc_output *mrc = &gd->arch.mrc[i];
 348                 void *data;
 349                 int size;
 350
 351                 size = mrc->len + MRC_DATA_HEADER_SIZE;
 352                 data = malloc(size);
 353                 if (!data)
 354                         return log_msg_ret("Allocate MRC cache block", -ENOMEM);
 355                 mrccache_setup(mrc, data);
 356         }
 357
 358         return mrccache_save();
 359 }