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 #include <common.h>
10 #include <dm.h>
11 #include <errno.h>
12 #include <fdtdec.h>
13 #include <net.h>
14 #include <spi.h>
15 #include <spi_flash.h>
16 #include <asm/mrccache.h>
17
18 DECLARE_GLOBAL_DATA_PTR;
19
mrc_block_size(uint data_size)20 static uint mrc_block_size(uint data_size)
21 {
22 uint mrc_size = sizeof(struct mrc_data_container) + data_size;
23
24 return ALIGN(mrc_size, MRC_DATA_ALIGN);
25 }
26
next_mrc_block(struct mrc_data_container * cache)27 static struct mrc_data_container *next_mrc_block(
28 struct mrc_data_container *cache)
29 {
30 /* MRC data blocks are aligned within the region */
31 u8 *region_ptr = (u8 *)cache;
32
33 region_ptr += mrc_block_size(cache->data_size);
34
35 return (struct mrc_data_container *)region_ptr;
36 }
37
is_mrc_cache(struct mrc_data_container * cache)38 static int is_mrc_cache(struct mrc_data_container *cache)
39 {
40 return cache && (cache->signature == MRC_DATA_SIGNATURE);
41 }
42
mrccache_find_current(struct mrc_region * entry)43 struct mrc_data_container *mrccache_find_current(struct mrc_region *entry)
44 {
45 struct mrc_data_container *cache, *next;
46 ulong base_addr, end_addr;
47 uint id;
48
49 base_addr = entry->base + entry->offset;
50 end_addr = base_addr + entry->length;
51 cache = NULL;
52
53 /* Search for the last filled entry in the region */
54 for (id = 0, next = (struct mrc_data_container *)base_addr;
55 is_mrc_cache(next);
56 id++) {
57 cache = next;
58 next = next_mrc_block(next);
59 if ((ulong)next >= end_addr)
60 break;
61 }
62
63 if (id-- == 0) {
64 debug("%s: No valid MRC cache found.\n", __func__);
65 return NULL;
66 }
67
68 /* Verify checksum */
69 if (cache->checksum != compute_ip_checksum(cache->data,
70 cache->data_size)) {
71 printf("%s: MRC cache checksum mismatch\n", __func__);
72 return NULL;
73 }
74
75 debug("%s: picked entry %u from cache block\n", __func__, id);
76
77 return cache;
78 }
79
80 /**
81 * find_next_mrc_cache() - get next cache entry
82 *
83 * @entry: MRC cache flash area
84 * @cache: Entry to start from
85 *
86 * @return next cache entry if found, NULL if we got to the end
87 */
find_next_mrc_cache(struct mrc_region * entry,struct mrc_data_container * cache)88 static struct mrc_data_container *find_next_mrc_cache(struct mrc_region *entry,
89 struct mrc_data_container *cache)
90 {
91 ulong base_addr, end_addr;
92
93 base_addr = entry->base + entry->offset;
94 end_addr = base_addr + entry->length;
95
96 cache = next_mrc_block(cache);
97 if ((ulong)cache >= end_addr) {
98 /* Crossed the boundary */
99 cache = NULL;
100 debug("%s: no available entries found\n", __func__);
101 } else {
102 debug("%s: picked next entry from cache block at %p\n",
103 __func__, cache);
104 }
105
106 return cache;
107 }
108
mrccache_update(struct udevice * sf,struct mrc_region * entry,struct mrc_data_container * cur)109 int mrccache_update(struct udevice *sf, struct mrc_region *entry,
110 struct mrc_data_container *cur)
111 {
112 struct mrc_data_container *cache;
113 ulong offset;
114 ulong base_addr;
115 int ret;
116
117 if (!is_mrc_cache(cur)) {
118 debug("%s: Cache data not valid\n", __func__);
119 return -EINVAL;
120 }
121
122 /* Find the last used block */
123 base_addr = entry->base + entry->offset;
124 debug("Updating MRC cache data\n");
125 cache = mrccache_find_current(entry);
126 if (cache && (cache->data_size == cur->data_size) &&
127 (!memcmp(cache, cur, cache->data_size + sizeof(*cur)))) {
128 debug("MRC data in flash is up to date. No update\n");
129 return -EEXIST;
130 }
131
132 /* Move to the next block, which will be the first unused block */
133 if (cache)
134 cache = find_next_mrc_cache(entry, cache);
135
136 /*
137 * If we have got to the end, erase the entire mrc-cache area and start
138 * again at block 0.
139 */
140 if (!cache) {
141 debug("Erasing the MRC cache region of %x bytes at %x\n",
142 entry->length, entry->offset);
143
144 ret = spi_flash_erase_dm(sf, entry->offset, entry->length);
145 if (ret) {
146 debug("Failed to erase flash region\n");
147 return ret;
148 }
149 cache = (struct mrc_data_container *)base_addr;
150 }
151
152 /* Write the data out */
153 offset = (ulong)cache - base_addr + entry->offset;
154 debug("Write MRC cache update to flash at %lx\n", offset);
155 ret = spi_flash_write_dm(sf, offset, cur->data_size + sizeof(*cur),
156 cur);
157 if (ret) {
158 debug("Failed to write to SPI flash\n");
159 return ret;
160 }
161
162 return 0;
163 }
164
mrccache_setup(void * data)165 static void mrccache_setup(void *data)
166 {
167 struct mrc_data_container *cache = data;
168 u16 checksum;
169
170 cache->signature = MRC_DATA_SIGNATURE;
171 cache->data_size = gd->arch.mrc_output_len;
172 checksum = compute_ip_checksum(gd->arch.mrc_output, cache->data_size);
173 debug("Saving %d bytes for MRC output data, checksum %04x\n",
174 cache->data_size, checksum);
175 cache->checksum = checksum;
176 cache->reserved = 0;
177 memcpy(cache->data, gd->arch.mrc_output, cache->data_size);
178
179 /* gd->arch.mrc_output now points to the container */
180 gd->arch.mrc_output = (char *)cache;
181 }
182
mrccache_reserve(void)183 int mrccache_reserve(void)
184 {
185 if (!gd->arch.mrc_output_len)
186 return 0;
187
188 /* adjust stack pointer to store pure cache data plus the header */
189 gd->start_addr_sp -= (gd->arch.mrc_output_len + MRC_DATA_HEADER_SIZE);
190 mrccache_setup((void *)gd->start_addr_sp);
191
192 gd->start_addr_sp &= ~0xf;
193
194 return 0;
195 }
196
mrccache_get_region(struct udevice ** devp,struct mrc_region * entry)197 int mrccache_get_region(struct udevice **devp, struct mrc_region *entry)
198 {
199 const void *blob = gd->fdt_blob;
200 int node, mrc_node;
201 u32 reg[2];
202 int ret;
203
204 /* Find the flash chip within the SPI controller node */
205 node = fdtdec_next_compatible(blob, 0, COMPAT_GENERIC_SPI_FLASH);
206 if (node < 0) {
207 debug("%s: Cannot find SPI flash\n", __func__);
208 return -ENOENT;
209 }
210
211 if (fdtdec_get_int_array(blob, node, "memory-map", reg, 2)) {
212 debug("%s: Cannot find memory map\n", __func__);
213 return -EINVAL;
214 }
215 entry->base = reg[0];
216
217 /* Find the place where we put the MRC cache */
218 mrc_node = fdt_subnode_offset(blob, node, "rw-mrc-cache");
219 if (mrc_node < 0) {
220 debug("%s: Cannot find node\n", __func__);
221 return -EPERM;
222 }
223
224 if (fdtdec_get_int_array(blob, mrc_node, "reg", reg, 2)) {
225 debug("%s: Cannot find address\n", __func__);
226 return -EINVAL;
227 }
228 entry->offset = reg[0];
229 entry->length = reg[1];
230
231 if (devp) {
232 ret = uclass_get_device_by_of_offset(UCLASS_SPI_FLASH, node,
233 devp);
234 debug("ret = %d\n", ret);
235 if (ret)
236 return ret;
237 }
238
239 return 0;
240 }
241
mrccache_save(void)242 int mrccache_save(void)
243 {
244 struct mrc_data_container *data;
245 struct mrc_region entry;
246 struct udevice *sf;
247 int ret;
248
249 if (!gd->arch.mrc_output_len)
250 return 0;
251 debug("Saving %d bytes of MRC output data to SPI flash\n",
252 gd->arch.mrc_output_len);
253
254 ret = mrccache_get_region(&sf, &entry);
255 if (ret)
256 goto err_entry;
257 data = (struct mrc_data_container *)gd->arch.mrc_output;
258 ret = mrccache_update(sf, &entry, data);
259 if (!ret) {
260 debug("Saved MRC data with checksum %04x\n", data->checksum);
261 } else if (ret == -EEXIST) {
262 debug("MRC data is the same as last time, skipping save\n");
263 ret = 0;
264 }
265
266 err_entry:
267 if (ret)
268 debug("%s: Failed: %d\n", __func__, ret);
269 return ret;
270 }
271
mrccache_spl_save(void)272 int mrccache_spl_save(void)
273 {
274 void *data;
275 int size;
276
277 size = gd->arch.mrc_output_len + MRC_DATA_HEADER_SIZE;
278 data = malloc(size);
279 if (!data)
280 return log_msg_ret("Allocate MRC cache block", -ENOMEM);
281 mrccache_setup(data);
282 gd->arch.mrc_output = data;
283
284 return mrccache_save();
285 }
286