1f593b1bdSAndrew Jeffery // SPDX-License-Identifier: Apache-2.0
2f593b1bdSAndrew Jeffery // Copyright (C) 2018 IBM Corp.
3f593b1bdSAndrew Jeffery
4f593b1bdSAndrew Jeffery #define _GNU_SOURCE
5f593b1bdSAndrew Jeffery #include <assert.h>
6f593b1bdSAndrew Jeffery #include <errno.h>
7f593b1bdSAndrew Jeffery #include <fcntl.h>
8f593b1bdSAndrew Jeffery #include <getopt.h>
9f593b1bdSAndrew Jeffery #include <limits.h>
10f593b1bdSAndrew Jeffery #include <poll.h>
11f593b1bdSAndrew Jeffery #include <stdbool.h>
12f593b1bdSAndrew Jeffery #include <stdint.h>
13f593b1bdSAndrew Jeffery #include <stdio.h>
14f593b1bdSAndrew Jeffery #include <stdlib.h>
15f593b1bdSAndrew Jeffery #include <string.h>
16f593b1bdSAndrew Jeffery #include <syslog.h>
17f593b1bdSAndrew Jeffery #include <signal.h>
18f593b1bdSAndrew Jeffery #include <sys/ioctl.h>
19f593b1bdSAndrew Jeffery #include <sys/mman.h>
20f593b1bdSAndrew Jeffery #include <sys/stat.h>
21f593b1bdSAndrew Jeffery #include <sys/timerfd.h>
22f593b1bdSAndrew Jeffery #include <sys/types.h>
23f593b1bdSAndrew Jeffery #include <time.h>
24f593b1bdSAndrew Jeffery #include <unistd.h>
25f593b1bdSAndrew Jeffery #include <inttypes.h>
26f593b1bdSAndrew Jeffery #include <mtd/mtd-abi.h>
27f593b1bdSAndrew Jeffery
2826558dbbSAndrew Jeffery #include "mboxd.h"
29f593b1bdSAndrew Jeffery #include "common.h"
30457a6e5fSAndrew Jeffery #include "transport_mbox.h"
31f593b1bdSAndrew Jeffery #include "windows.h"
32f1e547c7SEvan Lojewski #include "backend.h"
33f593b1bdSAndrew Jeffery
34*68a24c9eSPatrick Williams #pragma GCC diagnostic push
35*68a24c9eSPatrick Williams #pragma GCC diagnostic ignored "-Wpointer-arith"
36*68a24c9eSPatrick Williams
37f593b1bdSAndrew Jeffery /* Initialisation Functions */
38f593b1bdSAndrew Jeffery
39f593b1bdSAndrew Jeffery /*
40f593b1bdSAndrew Jeffery * init_window_state() - Initialise a new window to a known state
41f593b1bdSAndrew Jeffery * @window: The window to initialise
42f593b1bdSAndrew Jeffery * @size: The size of the window
43f593b1bdSAndrew Jeffery */
init_window_state(struct window_context * window,uint32_t size)44f593b1bdSAndrew Jeffery static void init_window_state(struct window_context *window, uint32_t size)
45f593b1bdSAndrew Jeffery {
46f593b1bdSAndrew Jeffery window->mem = NULL;
47f593b1bdSAndrew Jeffery window->flash_offset = FLASH_OFFSET_UNINIT;
48f593b1bdSAndrew Jeffery window->size = size;
49f593b1bdSAndrew Jeffery window->dirty_bmap = NULL;
50f593b1bdSAndrew Jeffery window->age = 0;
51f593b1bdSAndrew Jeffery }
52f593b1bdSAndrew Jeffery
53f593b1bdSAndrew Jeffery /*
54f593b1bdSAndrew Jeffery * init_window_mem() - Divide the reserved memory region among the windows
55f593b1bdSAndrew Jeffery * @context: The mbox context pointer
56f593b1bdSAndrew Jeffery *
57f593b1bdSAndrew Jeffery * Return: 0 on success otherwise negative error code
58f593b1bdSAndrew Jeffery */
init_window_mem(struct mbox_context * context)59f593b1bdSAndrew Jeffery static int init_window_mem(struct mbox_context *context)
60f593b1bdSAndrew Jeffery {
61f593b1bdSAndrew Jeffery void *mem_location = context->mem;
62*68a24c9eSPatrick Williams size_t i;
63f593b1bdSAndrew Jeffery
64f593b1bdSAndrew Jeffery /*
65f593b1bdSAndrew Jeffery * Carve up the reserved memory region and allocate it to each of the
66f593b1bdSAndrew Jeffery * windows. The windows are placed one after the other in ascending
67f593b1bdSAndrew Jeffery * order, so the first window will be first in memory and so on. We
68f593b1bdSAndrew Jeffery * shouldn't have allocated more windows than we have memory, but if we
69f593b1bdSAndrew Jeffery * did we will error out here
70f593b1bdSAndrew Jeffery */
71f593b1bdSAndrew Jeffery for (i = 0; i < context->windows.num; i++) {
72f593b1bdSAndrew Jeffery uint32_t size = context->windows.window[i].size;
73*68a24c9eSPatrick Williams MSG_DBG("Window %zd @ %p for size 0x%.8x\n", i,
74f593b1bdSAndrew Jeffery mem_location, size);
75f593b1bdSAndrew Jeffery context->windows.window[i].mem = mem_location;
76f593b1bdSAndrew Jeffery mem_location += size;
77f593b1bdSAndrew Jeffery if (mem_location > (context->mem + context->mem_size)) {
78f593b1bdSAndrew Jeffery /* Tried to allocate window past the end of memory */
79f593b1bdSAndrew Jeffery MSG_ERR("Total size of windows exceeds reserved mem\n");
80f593b1bdSAndrew Jeffery MSG_ERR("Try smaller or fewer windows\n");
81f593b1bdSAndrew Jeffery MSG_ERR("Mem size: 0x%.8x\n", context->mem_size);
82f593b1bdSAndrew Jeffery return -1;
83f593b1bdSAndrew Jeffery }
84f593b1bdSAndrew Jeffery }
85f593b1bdSAndrew Jeffery
86f593b1bdSAndrew Jeffery return 0;
87f593b1bdSAndrew Jeffery }
88f593b1bdSAndrew Jeffery /*
89c1a67fa8SAndrew Jeffery * windows_init() - Initalise the window cache
90f593b1bdSAndrew Jeffery * @context: The mbox context pointer
91f593b1bdSAndrew Jeffery *
92f593b1bdSAndrew Jeffery * Return: 0 on success otherwise negative
93f593b1bdSAndrew Jeffery */
windows_init(struct mbox_context * context)94c1a67fa8SAndrew Jeffery int windows_init(struct mbox_context *context)
95f593b1bdSAndrew Jeffery {
96*68a24c9eSPatrick Williams size_t i;
97f593b1bdSAndrew Jeffery
98f593b1bdSAndrew Jeffery /* Check if window size and number set - otherwise set to default */
99f593b1bdSAndrew Jeffery if (!context->windows.default_size) {
100f593b1bdSAndrew Jeffery /* Default to 1MB windows */
101f593b1bdSAndrew Jeffery context->windows.default_size = 1 << 20;
102f593b1bdSAndrew Jeffery }
103f593b1bdSAndrew Jeffery MSG_INFO("Window size: 0x%.8x\n", context->windows.default_size);
104f593b1bdSAndrew Jeffery if (!context->windows.num) {
105f593b1bdSAndrew Jeffery /* Use the entire reserved memory region by default */
106f593b1bdSAndrew Jeffery context->windows.num = context->mem_size /
107f593b1bdSAndrew Jeffery context->windows.default_size;
108f593b1bdSAndrew Jeffery }
109f593b1bdSAndrew Jeffery MSG_INFO("Number of windows: %d\n", context->windows.num);
110f593b1bdSAndrew Jeffery
111f593b1bdSAndrew Jeffery context->windows.window = calloc(context->windows.num,
112f593b1bdSAndrew Jeffery sizeof(*context->windows.window));
113f593b1bdSAndrew Jeffery if (!context->windows.window) {
114f593b1bdSAndrew Jeffery MSG_ERR("Memory allocation failed\n");
115f593b1bdSAndrew Jeffery return -1;
116f593b1bdSAndrew Jeffery }
117f593b1bdSAndrew Jeffery
118f593b1bdSAndrew Jeffery for (i = 0; i < context->windows.num; i++) {
119f593b1bdSAndrew Jeffery init_window_state(&context->windows.window[i],
120f593b1bdSAndrew Jeffery context->windows.default_size);
121f593b1bdSAndrew Jeffery }
122f593b1bdSAndrew Jeffery
123f593b1bdSAndrew Jeffery return init_window_mem(context);
124f593b1bdSAndrew Jeffery }
125f593b1bdSAndrew Jeffery
126f593b1bdSAndrew Jeffery /*
127f5f51428SAndrew Jeffery * windows_free() - Free the window cache
128f593b1bdSAndrew Jeffery * @context: The mbox context pointer
129f593b1bdSAndrew Jeffery */
windows_free(struct mbox_context * context)130f5f51428SAndrew Jeffery void windows_free(struct mbox_context *context)
131f593b1bdSAndrew Jeffery {
132*68a24c9eSPatrick Williams size_t i;
133f593b1bdSAndrew Jeffery
134f593b1bdSAndrew Jeffery /* Check window cache has actually been allocated */
135f593b1bdSAndrew Jeffery if (context->windows.window) {
136f593b1bdSAndrew Jeffery for (i = 0; i < context->windows.num; i++) {
137f593b1bdSAndrew Jeffery free(context->windows.window[i].dirty_bmap);
138f593b1bdSAndrew Jeffery }
139f593b1bdSAndrew Jeffery free(context->windows.window);
140f593b1bdSAndrew Jeffery }
141f593b1bdSAndrew Jeffery }
142f593b1bdSAndrew Jeffery
143f593b1bdSAndrew Jeffery /* Write from Window Functions */
144f593b1bdSAndrew Jeffery
145f593b1bdSAndrew Jeffery /*
1463200c072SAndrew Jeffery * window_flush_v1() - Handle writing when erase and block size differ
147f593b1bdSAndrew Jeffery * @context: The mbox context pointer
148f593b1bdSAndrew Jeffery * @offset_bytes: The offset in the current window to write from (bytes)
149f593b1bdSAndrew Jeffery * @count_bytes: Number of bytes to write
150f593b1bdSAndrew Jeffery *
1513200c072SAndrew Jeffery * Handle a window_flush for dirty memory when block_size is less than the
152f593b1bdSAndrew Jeffery * flash erase size
153f593b1bdSAndrew Jeffery * This requires us to be a bit careful because we might have to erase more
154f593b1bdSAndrew Jeffery * than we want to write which could result in data loss if we don't have the
155f593b1bdSAndrew Jeffery * entire portion of flash to be erased already saved in memory (for us to
156f593b1bdSAndrew Jeffery * write back after the erase)
157f593b1bdSAndrew Jeffery *
158f593b1bdSAndrew Jeffery * Return: 0 on success otherwise negative error code
159f593b1bdSAndrew Jeffery */
window_flush_v1(struct mbox_context * context,uint32_t offset_bytes,uint32_t count_bytes)1603200c072SAndrew Jeffery int window_flush_v1(struct mbox_context *context,
161f593b1bdSAndrew Jeffery uint32_t offset_bytes, uint32_t count_bytes)
162f593b1bdSAndrew Jeffery {
163f593b1bdSAndrew Jeffery int rc;
164f593b1bdSAndrew Jeffery uint32_t flash_offset;
165f593b1bdSAndrew Jeffery struct window_context low_mem = { 0 }, high_mem = { 0 };
166f593b1bdSAndrew Jeffery
167f593b1bdSAndrew Jeffery /* Find where in phys flash this is based on the window.flash_offset */
168f593b1bdSAndrew Jeffery flash_offset = context->current->flash_offset + offset_bytes;
169f593b1bdSAndrew Jeffery
170f593b1bdSAndrew Jeffery /*
171f593b1bdSAndrew Jeffery * low_mem.flash_offset = erase boundary below where we're writing
172f593b1bdSAndrew Jeffery * low_mem.size = size from low_mem.flash_offset to where we're writing
173f593b1bdSAndrew Jeffery *
174f593b1bdSAndrew Jeffery * high_mem.flash_offset = end of where we're writing
175f593b1bdSAndrew Jeffery * high_mem.size = size from end of where we're writing to next erase
176f593b1bdSAndrew Jeffery * boundary
177f593b1bdSAndrew Jeffery */
178f593b1bdSAndrew Jeffery low_mem.flash_offset = align_down(flash_offset,
179f1e547c7SEvan Lojewski 1 << context->backend.erase_size_shift);
180f593b1bdSAndrew Jeffery low_mem.size = flash_offset - low_mem.flash_offset;
181f593b1bdSAndrew Jeffery high_mem.flash_offset = flash_offset + count_bytes;
182f593b1bdSAndrew Jeffery high_mem.size = align_up(high_mem.flash_offset,
183f1e547c7SEvan Lojewski 1 << context->backend.erase_size_shift) -
184f593b1bdSAndrew Jeffery high_mem.flash_offset;
185f593b1bdSAndrew Jeffery
186f593b1bdSAndrew Jeffery /*
187f593b1bdSAndrew Jeffery * Check if we already have a copy of the required flash areas in
188f593b1bdSAndrew Jeffery * memory as part of the existing window
189f593b1bdSAndrew Jeffery */
190f593b1bdSAndrew Jeffery if (low_mem.flash_offset < context->current->flash_offset) {
191f593b1bdSAndrew Jeffery /* Before the start of our current window */
192f593b1bdSAndrew Jeffery low_mem.mem = malloc(low_mem.size);
193f593b1bdSAndrew Jeffery if (!low_mem.mem) {
194f593b1bdSAndrew Jeffery MSG_ERR("Unable to allocate memory\n");
1958eab2151SAndrew Jeffery return -ENOMEM;
196f593b1bdSAndrew Jeffery }
1970297e5b8SAndrew Jeffery rc = backend_copy(&context->backend, low_mem.flash_offset,
198f593b1bdSAndrew Jeffery low_mem.mem, low_mem.size);
199f593b1bdSAndrew Jeffery if (rc < 0) {
200f593b1bdSAndrew Jeffery goto out;
201f593b1bdSAndrew Jeffery }
202f593b1bdSAndrew Jeffery }
203f593b1bdSAndrew Jeffery if ((high_mem.flash_offset + high_mem.size) >
204f593b1bdSAndrew Jeffery (context->current->flash_offset + context->current->size)) {
205f593b1bdSAndrew Jeffery /* After the end of our current window */
206f593b1bdSAndrew Jeffery high_mem.mem = malloc(high_mem.size);
207f593b1bdSAndrew Jeffery if (!high_mem.mem) {
208f593b1bdSAndrew Jeffery MSG_ERR("Unable to allocate memory\n");
2098eab2151SAndrew Jeffery rc = -ENOMEM;
210f593b1bdSAndrew Jeffery goto out;
211f593b1bdSAndrew Jeffery }
2120297e5b8SAndrew Jeffery rc = backend_copy(&context->backend, high_mem.flash_offset,
213f593b1bdSAndrew Jeffery high_mem.mem, high_mem.size);
214f593b1bdSAndrew Jeffery if (rc < 0) {
215f593b1bdSAndrew Jeffery goto out;
216f593b1bdSAndrew Jeffery }
217f593b1bdSAndrew Jeffery }
218f593b1bdSAndrew Jeffery
219f593b1bdSAndrew Jeffery /*
220f593b1bdSAndrew Jeffery * We need to erase the flash from low_mem.flash_offset->
221f593b1bdSAndrew Jeffery * high_mem.flash_offset + high_mem.size
222f593b1bdSAndrew Jeffery */
2230297e5b8SAndrew Jeffery rc = backend_erase(&context->backend, low_mem.flash_offset,
224f593b1bdSAndrew Jeffery (high_mem.flash_offset - low_mem.flash_offset) +
225f593b1bdSAndrew Jeffery high_mem.size);
226f593b1bdSAndrew Jeffery if (rc < 0) {
227f593b1bdSAndrew Jeffery MSG_ERR("Couldn't erase flash\n");
228f593b1bdSAndrew Jeffery goto out;
229f593b1bdSAndrew Jeffery }
230f593b1bdSAndrew Jeffery
231f593b1bdSAndrew Jeffery /* Write back over the erased area */
232f593b1bdSAndrew Jeffery if (low_mem.mem) {
233f593b1bdSAndrew Jeffery /* Exceed window at the start */
2340297e5b8SAndrew Jeffery rc = backend_write(&context->backend, low_mem.flash_offset,
2350297e5b8SAndrew Jeffery low_mem.mem, low_mem.size);
236f593b1bdSAndrew Jeffery if (rc < 0) {
237f593b1bdSAndrew Jeffery goto out;
238f593b1bdSAndrew Jeffery }
239f593b1bdSAndrew Jeffery }
2400297e5b8SAndrew Jeffery rc = backend_write(&context->backend, flash_offset,
241f593b1bdSAndrew Jeffery context->current->mem + offset_bytes, count_bytes);
242f593b1bdSAndrew Jeffery if (rc < 0) {
243f593b1bdSAndrew Jeffery goto out;
244f593b1bdSAndrew Jeffery }
245f593b1bdSAndrew Jeffery /*
246f593b1bdSAndrew Jeffery * We still need to write the last little bit that we erased - it's
247f593b1bdSAndrew Jeffery * either in the current window or the high_mem window.
248f593b1bdSAndrew Jeffery */
249f593b1bdSAndrew Jeffery if (high_mem.mem) {
250f593b1bdSAndrew Jeffery /* Exceed window at the end */
2510297e5b8SAndrew Jeffery rc = backend_write(&context->backend, high_mem.flash_offset,
2520297e5b8SAndrew Jeffery high_mem.mem, high_mem.size);
253f593b1bdSAndrew Jeffery if (rc < 0) {
254f593b1bdSAndrew Jeffery goto out;
255f593b1bdSAndrew Jeffery }
256f593b1bdSAndrew Jeffery } else {
257f593b1bdSAndrew Jeffery /* Write from the current window - it's atleast that big */
2580297e5b8SAndrew Jeffery rc = backend_write(&context->backend, high_mem.flash_offset,
259f593b1bdSAndrew Jeffery context->current->mem + offset_bytes +
260f593b1bdSAndrew Jeffery count_bytes, high_mem.size);
261f593b1bdSAndrew Jeffery if (rc < 0) {
262f593b1bdSAndrew Jeffery goto out;
263f593b1bdSAndrew Jeffery }
264f593b1bdSAndrew Jeffery }
265f593b1bdSAndrew Jeffery
266f593b1bdSAndrew Jeffery out:
267f593b1bdSAndrew Jeffery free(low_mem.mem);
268f593b1bdSAndrew Jeffery free(high_mem.mem);
269f593b1bdSAndrew Jeffery return rc;
270f593b1bdSAndrew Jeffery }
271f593b1bdSAndrew Jeffery
272f593b1bdSAndrew Jeffery /*
2733200c072SAndrew Jeffery * window_flush() - Write back to the flash from the current window
274f593b1bdSAndrew Jeffery * @context: The mbox context pointer
275f593b1bdSAndrew Jeffery * @offset_bytes: The offset in the current window to write from (blocks)
276f593b1bdSAndrew Jeffery * @count_bytes: Number of blocks to write
277f593b1bdSAndrew Jeffery * @type: Whether this is an erase & write or just an erase
278f593b1bdSAndrew Jeffery *
279f593b1bdSAndrew Jeffery * Return: 0 on success otherwise negative error code
280f593b1bdSAndrew Jeffery */
window_flush(struct mbox_context * context,uint32_t offset,uint32_t count,uint8_t type)2813200c072SAndrew Jeffery int window_flush(struct mbox_context *context, uint32_t offset,
282f593b1bdSAndrew Jeffery uint32_t count, uint8_t type)
283f593b1bdSAndrew Jeffery {
284f593b1bdSAndrew Jeffery int rc;
285f1e547c7SEvan Lojewski uint32_t flash_offset, count_bytes = count << context->backend.block_size_shift;
286f1e547c7SEvan Lojewski uint32_t offset_bytes = offset << context->backend.block_size_shift;
287f593b1bdSAndrew Jeffery
288f593b1bdSAndrew Jeffery switch (type) {
289f593b1bdSAndrew Jeffery case WINDOW_ERASED: /* >= V2 ONLY -> block_size == erasesize */
290f593b1bdSAndrew Jeffery flash_offset = context->current->flash_offset + offset_bytes;
2910297e5b8SAndrew Jeffery rc = backend_erase(&context->backend, flash_offset,
2920297e5b8SAndrew Jeffery count_bytes);
293f593b1bdSAndrew Jeffery if (rc < 0) {
294f593b1bdSAndrew Jeffery MSG_ERR("Couldn't erase flash\n");
295f593b1bdSAndrew Jeffery return rc;
296f593b1bdSAndrew Jeffery }
297f593b1bdSAndrew Jeffery break;
298f593b1bdSAndrew Jeffery case WINDOW_DIRTY:
299f593b1bdSAndrew Jeffery /*
300f593b1bdSAndrew Jeffery * For protocol V1, block_size may be smaller than erase size
301f593b1bdSAndrew Jeffery * so we have a special function to make sure that we do this
302f593b1bdSAndrew Jeffery * correctly without losing data.
303f593b1bdSAndrew Jeffery */
304f1e547c7SEvan Lojewski if (context->backend.erase_size_shift !=
305f1e547c7SEvan Lojewski context->backend.block_size_shift) {
3063200c072SAndrew Jeffery return window_flush_v1(context, offset_bytes,
307f593b1bdSAndrew Jeffery count_bytes);
308f593b1bdSAndrew Jeffery }
309f593b1bdSAndrew Jeffery flash_offset = context->current->flash_offset + offset_bytes;
310f593b1bdSAndrew Jeffery
311f593b1bdSAndrew Jeffery /* Erase the flash */
3120297e5b8SAndrew Jeffery rc = backend_erase(&context->backend, flash_offset,
3130297e5b8SAndrew Jeffery count_bytes);
314f593b1bdSAndrew Jeffery if (rc < 0) {
315f593b1bdSAndrew Jeffery return rc;
316f593b1bdSAndrew Jeffery }
317f593b1bdSAndrew Jeffery
318f593b1bdSAndrew Jeffery /* Write to the erased flash */
3190297e5b8SAndrew Jeffery rc = backend_write(&context->backend, flash_offset,
320f593b1bdSAndrew Jeffery context->current->mem + offset_bytes,
321f593b1bdSAndrew Jeffery count_bytes);
322f593b1bdSAndrew Jeffery if (rc < 0) {
323f593b1bdSAndrew Jeffery return rc;
324f593b1bdSAndrew Jeffery }
325f593b1bdSAndrew Jeffery
326f593b1bdSAndrew Jeffery break;
327f593b1bdSAndrew Jeffery default:
328f593b1bdSAndrew Jeffery /* We shouldn't be able to get here */
329f593b1bdSAndrew Jeffery MSG_ERR("Write from window with invalid type: %d\n", type);
3308eab2151SAndrew Jeffery return -EPERM;
331f593b1bdSAndrew Jeffery }
332f593b1bdSAndrew Jeffery
333f593b1bdSAndrew Jeffery return 0;
334f593b1bdSAndrew Jeffery }
335f593b1bdSAndrew Jeffery
336f593b1bdSAndrew Jeffery /* Window Management Functions */
337f593b1bdSAndrew Jeffery
338f593b1bdSAndrew Jeffery /*
339348ea792SAndrew Jeffery * windows_alloc_dirty_bytemap() - (re)allocate all the window dirty bytemaps
340f593b1bdSAndrew Jeffery * @context: The mbox context pointer
341f593b1bdSAndrew Jeffery */
windows_alloc_dirty_bytemap(struct mbox_context * context)342348ea792SAndrew Jeffery void windows_alloc_dirty_bytemap(struct mbox_context *context)
343f593b1bdSAndrew Jeffery {
344f593b1bdSAndrew Jeffery struct window_context *cur;
345*68a24c9eSPatrick Williams size_t i;
346f593b1bdSAndrew Jeffery
347f593b1bdSAndrew Jeffery for (i = 0; i < context->windows.num; i++) {
348f593b1bdSAndrew Jeffery cur = &context->windows.window[i];
349f593b1bdSAndrew Jeffery /* There may already be one allocated */
350f593b1bdSAndrew Jeffery free(cur->dirty_bmap);
351f593b1bdSAndrew Jeffery /* Allocate the new one */
35241c337e8SAndrew Jeffery cur->dirty_bmap = calloc((context->windows.default_size >>
353f1e547c7SEvan Lojewski context->backend.block_size_shift),
354f593b1bdSAndrew Jeffery sizeof(*cur->dirty_bmap));
355f593b1bdSAndrew Jeffery }
356f593b1bdSAndrew Jeffery }
357f593b1bdSAndrew Jeffery
358f593b1bdSAndrew Jeffery /*
3597d5ada63SAndrew Jeffery * window_set_bytemap() - Set the window bytemap
360f593b1bdSAndrew Jeffery * @context: The mbox context pointer
361f593b1bdSAndrew Jeffery * @cur: The window to set the bytemap of
362f593b1bdSAndrew Jeffery * @offset: Where in the window to set the bytemap (blocks)
363f593b1bdSAndrew Jeffery * @size: The number of blocks to set
364f593b1bdSAndrew Jeffery * @val: The value to set the bytemap to
365f593b1bdSAndrew Jeffery *
366f593b1bdSAndrew Jeffery * Return: 0 on success otherwise negative error code
367f593b1bdSAndrew Jeffery */
window_set_bytemap(struct mbox_context * context,struct window_context * cur,uint32_t offset,uint32_t size,uint8_t val)3687d5ada63SAndrew Jeffery int window_set_bytemap(struct mbox_context *context, struct window_context *cur,
369f593b1bdSAndrew Jeffery uint32_t offset, uint32_t size, uint8_t val)
370f593b1bdSAndrew Jeffery {
371f1e547c7SEvan Lojewski if (offset + size > (cur->size >> context->backend.block_size_shift)) {
372f593b1bdSAndrew Jeffery MSG_ERR("Tried to set window bytemap past end of window\n");
373f593b1bdSAndrew Jeffery MSG_ERR("Requested offset: 0x%x size: 0x%x window size: 0x%x\n",
374f1e547c7SEvan Lojewski offset << context->backend.block_size_shift,
375f1e547c7SEvan Lojewski size << context->backend.block_size_shift,
376f1e547c7SEvan Lojewski cur->size << context->backend.block_size_shift);
377f593b1bdSAndrew Jeffery return -EACCES;
378f593b1bdSAndrew Jeffery }
379f593b1bdSAndrew Jeffery
380f593b1bdSAndrew Jeffery memset(cur->dirty_bmap + offset, val, size);
381f593b1bdSAndrew Jeffery return 0;
382f593b1bdSAndrew Jeffery }
383f593b1bdSAndrew Jeffery
384f593b1bdSAndrew Jeffery /*
385b65bb4c5SAndrew Jeffery * windows_close_current() - Close the current (active) window
386f593b1bdSAndrew Jeffery * @context: The mbox context pointer
387f593b1bdSAndrew Jeffery * @flags: Flags as defined for a close command in the protocol
388f593b1bdSAndrew Jeffery *
389f593b1bdSAndrew Jeffery * This closes the current window. If the host has requested the current window
390f593b1bdSAndrew Jeffery * be closed then we don't need to set the bmc event bit
391f593b1bdSAndrew Jeffery * (set_bmc_event == false), otherwise if the current window has been closed
392f593b1bdSAndrew Jeffery * without the host requesting it the bmc event bit must be set to indicate this
393f593b1bdSAndrew Jeffery * to the host (set_bmc_event == true).
394f593b1bdSAndrew Jeffery */
windows_close_current(struct mbox_context * context,uint8_t flags)3952ebfd20fSAndrew Jeffery void windows_close_current(struct mbox_context *context, uint8_t flags)
396f593b1bdSAndrew Jeffery {
397f593b1bdSAndrew Jeffery MSG_DBG("Close current window, flags: 0x%.2x\n", flags);
398f593b1bdSAndrew Jeffery
399f593b1bdSAndrew Jeffery if (flags & FLAGS_SHORT_LIFETIME) {
400f593b1bdSAndrew Jeffery context->current->age = 0;
401f593b1bdSAndrew Jeffery }
402f593b1bdSAndrew Jeffery
403f593b1bdSAndrew Jeffery context->current = NULL;
404f593b1bdSAndrew Jeffery context->current_is_write = false;
405f593b1bdSAndrew Jeffery }
406f593b1bdSAndrew Jeffery
407f593b1bdSAndrew Jeffery /*
4085dc9f959SAndrew Jeffery * window_reset() - Reset a window context to a well defined default state
409f593b1bdSAndrew Jeffery * @context: The mbox context pointer
410f593b1bdSAndrew Jeffery * @window: The window to reset
411f593b1bdSAndrew Jeffery */
window_reset(struct mbox_context * context,struct window_context * window)4125dc9f959SAndrew Jeffery void window_reset(struct mbox_context *context, struct window_context *window)
413f593b1bdSAndrew Jeffery {
414f593b1bdSAndrew Jeffery window->flash_offset = FLASH_OFFSET_UNINIT;
415f593b1bdSAndrew Jeffery window->size = context->windows.default_size;
416f593b1bdSAndrew Jeffery if (window->dirty_bmap) { /* Might not have been allocated */
4177d5ada63SAndrew Jeffery window_set_bytemap(context, window, 0,
418f1e547c7SEvan Lojewski window->size >> context->backend.block_size_shift,
419f593b1bdSAndrew Jeffery WINDOW_CLEAN);
420f593b1bdSAndrew Jeffery }
421f593b1bdSAndrew Jeffery window->age = 0;
422f593b1bdSAndrew Jeffery }
423f593b1bdSAndrew Jeffery
424f593b1bdSAndrew Jeffery /*
425d6a7426eSAndrew Jeffery * windows_reset_all() - Reset all windows to a well defined default state
426f593b1bdSAndrew Jeffery * @context: The mbox context pointer
4272ebfd20fSAndrew Jeffery *
4282ebfd20fSAndrew Jeffery * @return True if there was a window open that was closed, false otherwise
429f593b1bdSAndrew Jeffery */
windows_reset_all(struct mbox_context * context)4302ebfd20fSAndrew Jeffery bool windows_reset_all(struct mbox_context *context)
431f593b1bdSAndrew Jeffery {
4322ebfd20fSAndrew Jeffery bool closed = context->current;
433*68a24c9eSPatrick Williams size_t i;
434f593b1bdSAndrew Jeffery
435f593b1bdSAndrew Jeffery MSG_DBG("Resetting all windows\n");
4362ebfd20fSAndrew Jeffery
4372ebfd20fSAndrew Jeffery context->windows.max_age = 0;
4382ebfd20fSAndrew Jeffery
439f593b1bdSAndrew Jeffery /* We might have an open window which needs closing */
4402ebfd20fSAndrew Jeffery
441f593b1bdSAndrew Jeffery if (context->current) {
4422ebfd20fSAndrew Jeffery windows_close_current(context, FLAGS_NONE);
443f593b1bdSAndrew Jeffery }
4442ebfd20fSAndrew Jeffery
445f593b1bdSAndrew Jeffery for (i = 0; i < context->windows.num; i++) {
4465dc9f959SAndrew Jeffery window_reset(context, &context->windows.window[i]);
447f593b1bdSAndrew Jeffery }
448f593b1bdSAndrew Jeffery
4492ebfd20fSAndrew Jeffery return closed;
450f593b1bdSAndrew Jeffery }
451f593b1bdSAndrew Jeffery
452f593b1bdSAndrew Jeffery /*
4539412f059SAndrew Jeffery * windows_find_oldest() - Find the oldest (Least Recently Used) window
454f593b1bdSAndrew Jeffery * @context: The mbox context pointer
455f593b1bdSAndrew Jeffery *
456f593b1bdSAndrew Jeffery * Return: Pointer to the least recently used window
457f593b1bdSAndrew Jeffery */
windows_find_oldest(struct mbox_context * context)4589412f059SAndrew Jeffery struct window_context *windows_find_oldest(struct mbox_context *context)
459f593b1bdSAndrew Jeffery {
460f593b1bdSAndrew Jeffery struct window_context *oldest = NULL, *cur;
461f593b1bdSAndrew Jeffery uint32_t min_age = context->windows.max_age + 1;
462*68a24c9eSPatrick Williams size_t i;
463f593b1bdSAndrew Jeffery
464f593b1bdSAndrew Jeffery for (i = 0; i < context->windows.num; i++) {
465f593b1bdSAndrew Jeffery cur = &context->windows.window[i];
466f593b1bdSAndrew Jeffery
467f593b1bdSAndrew Jeffery if (cur->age < min_age) {
468f593b1bdSAndrew Jeffery min_age = cur->age;
469f593b1bdSAndrew Jeffery oldest = cur;
470f593b1bdSAndrew Jeffery }
471f593b1bdSAndrew Jeffery }
472f593b1bdSAndrew Jeffery
473f593b1bdSAndrew Jeffery return oldest;
474f593b1bdSAndrew Jeffery }
475f593b1bdSAndrew Jeffery
476f593b1bdSAndrew Jeffery /*
477d8c12e1bSAndrew Jeffery * windows_find_largest() - Find the largest window in the window cache
478f593b1bdSAndrew Jeffery * @context: The mbox context pointer
479f593b1bdSAndrew Jeffery *
480f593b1bdSAndrew Jeffery * Return: The largest window
481f593b1bdSAndrew Jeffery */
windows_find_largest(struct mbox_context * context)482d8c12e1bSAndrew Jeffery struct window_context *windows_find_largest(struct mbox_context *context)
483f593b1bdSAndrew Jeffery {
484f593b1bdSAndrew Jeffery struct window_context *largest = NULL, *cur;
485f593b1bdSAndrew Jeffery uint32_t max_size = 0;
486*68a24c9eSPatrick Williams size_t i;
487f593b1bdSAndrew Jeffery
488f593b1bdSAndrew Jeffery for (i = 0; i < context->windows.num; i++) {
489f593b1bdSAndrew Jeffery cur = &context->windows.window[i];
490f593b1bdSAndrew Jeffery
491f593b1bdSAndrew Jeffery if (cur->size > max_size) {
492f593b1bdSAndrew Jeffery max_size = cur->size;
493f593b1bdSAndrew Jeffery largest = cur;
494f593b1bdSAndrew Jeffery }
495f593b1bdSAndrew Jeffery }
496f593b1bdSAndrew Jeffery
497f593b1bdSAndrew Jeffery return largest;
498f593b1bdSAndrew Jeffery }
499f593b1bdSAndrew Jeffery
500f593b1bdSAndrew Jeffery /*
50117c477a7SAndrew Jeffery * windows_search() - Search the window cache for a window containing offset
502f593b1bdSAndrew Jeffery * @context: The mbox context pointer
503f593b1bdSAndrew Jeffery * @offset: Absolute flash offset to search for (bytes)
504f593b1bdSAndrew Jeffery * @exact: If the window must exactly map the requested offset
505f593b1bdSAndrew Jeffery *
506f593b1bdSAndrew Jeffery * This will search the cache of windows for one containing the requested
507f593b1bdSAndrew Jeffery * offset. For V1 of the protocol windows must exactly map the offset since we
508f593b1bdSAndrew Jeffery * can't tell the host how much of its request we actually mapped and it will
509f593b1bdSAndrew Jeffery * thus assume it can access window->size from the offset we give it.
510f593b1bdSAndrew Jeffery *
511f593b1bdSAndrew Jeffery * Return: Pointer to a window containing the requested offset otherwise
512f593b1bdSAndrew Jeffery * NULL
513f593b1bdSAndrew Jeffery */
windows_search(struct mbox_context * context,uint32_t offset,bool exact)51417c477a7SAndrew Jeffery struct window_context *windows_search(struct mbox_context *context,
515f593b1bdSAndrew Jeffery uint32_t offset, bool exact)
516f593b1bdSAndrew Jeffery {
517f593b1bdSAndrew Jeffery struct window_context *cur;
518*68a24c9eSPatrick Williams size_t i;
519f593b1bdSAndrew Jeffery
520f593b1bdSAndrew Jeffery MSG_DBG("Searching for window which contains 0x%.8x %s\n",
521f593b1bdSAndrew Jeffery offset, exact ? "exactly" : "");
522f593b1bdSAndrew Jeffery for (i = 0; i < context->windows.num; i++) {
523f593b1bdSAndrew Jeffery cur = &context->windows.window[i];
524f593b1bdSAndrew Jeffery if (cur->flash_offset == FLASH_OFFSET_UNINIT) {
525f593b1bdSAndrew Jeffery /* Uninitialised Window */
526f593b1bdSAndrew Jeffery if (offset == FLASH_OFFSET_UNINIT) {
527f593b1bdSAndrew Jeffery return cur;
528f593b1bdSAndrew Jeffery }
529f593b1bdSAndrew Jeffery continue;
530f593b1bdSAndrew Jeffery }
531f593b1bdSAndrew Jeffery if ((offset >= cur->flash_offset) &&
532f593b1bdSAndrew Jeffery (offset < (cur->flash_offset + cur->size))) {
533f593b1bdSAndrew Jeffery if (exact && (cur->flash_offset != offset)) {
534f593b1bdSAndrew Jeffery continue;
535f593b1bdSAndrew Jeffery }
536f593b1bdSAndrew Jeffery /* This window contains the requested offset */
537f593b1bdSAndrew Jeffery cur->age = ++(context->windows.max_age);
538f593b1bdSAndrew Jeffery return cur;
539f593b1bdSAndrew Jeffery }
540f593b1bdSAndrew Jeffery }
541f593b1bdSAndrew Jeffery
542f593b1bdSAndrew Jeffery return NULL;
543f593b1bdSAndrew Jeffery }
544f593b1bdSAndrew Jeffery
545f593b1bdSAndrew Jeffery /*
546ebbfce5eSAndrew Jeffery * windows_create_map() - Create a window mapping which maps the requested offset
547f593b1bdSAndrew Jeffery * @context: The mbox context pointer
548f593b1bdSAndrew Jeffery * @this_window: A pointer to update to the "new" window
549f593b1bdSAndrew Jeffery * @offset: Absolute flash offset to create a mapping for (bytes)
550f593b1bdSAndrew Jeffery * @exact: If the window must exactly map the requested offset
551f593b1bdSAndrew Jeffery *
552f593b1bdSAndrew Jeffery * This is used to create a window mapping for the requested offset when there
553f593b1bdSAndrew Jeffery * is no existing window in the cache which satisfies the offset. This involves
554f593b1bdSAndrew Jeffery * choosing an existing window from the window cache to evict so we can use it
555f593b1bdSAndrew Jeffery * to store the flash contents from the requested offset, we then point the
556f593b1bdSAndrew Jeffery * caller to that window since it now maps their request.
557f593b1bdSAndrew Jeffery *
558f593b1bdSAndrew Jeffery * Return: 0 on success otherwise negative error code
559f593b1bdSAndrew Jeffery */
windows_create_map(struct mbox_context * context,struct window_context ** this_window,uint32_t offset,bool exact)560ebbfce5eSAndrew Jeffery int windows_create_map(struct mbox_context *context,
561f593b1bdSAndrew Jeffery struct window_context **this_window, uint32_t offset,
562f593b1bdSAndrew Jeffery bool exact)
563f593b1bdSAndrew Jeffery {
564f593b1bdSAndrew Jeffery struct window_context *cur = NULL;
565f593b1bdSAndrew Jeffery int rc;
566f593b1bdSAndrew Jeffery
567f593b1bdSAndrew Jeffery MSG_DBG("Creating window which maps 0x%.8x %s\n", offset,
568f593b1bdSAndrew Jeffery exact ? "exactly" : "");
569f593b1bdSAndrew Jeffery
570f593b1bdSAndrew Jeffery /* Search for an uninitialised window, use this before evicting */
57117c477a7SAndrew Jeffery cur = windows_search(context, FLASH_OFFSET_UNINIT, true);
572f593b1bdSAndrew Jeffery
573f593b1bdSAndrew Jeffery /* No uninitialised window found, we need to choose one to "evict" */
574f593b1bdSAndrew Jeffery if (!cur) {
575f593b1bdSAndrew Jeffery MSG_DBG("No uninitialised window, evicting one\n");
5769412f059SAndrew Jeffery cur = windows_find_oldest(context);
5775dc9f959SAndrew Jeffery window_reset(context, cur);
578f593b1bdSAndrew Jeffery }
579f593b1bdSAndrew Jeffery
5808cef63e3SAlvin Wang /* Adjust the offset for alignment by the backend. It will help prevent the
5818cef63e3SAlvin Wang * overlap.
582f593b1bdSAndrew Jeffery */
583f593b1bdSAndrew Jeffery if (!exact) {
5848cef63e3SAlvin Wang if (backend_align_offset(&(context->backend), &offset, cur->size)) {
5858cef63e3SAlvin Wang MSG_ERR("Can't adjust the offset by backend\n");
586f593b1bdSAndrew Jeffery }
5878cef63e3SAlvin Wang }
588f593b1bdSAndrew Jeffery
589f1e547c7SEvan Lojewski if (offset > context->backend.flash_size) {
590f593b1bdSAndrew Jeffery MSG_ERR("Tried to open read window past flash limit\n");
5918eab2151SAndrew Jeffery return -EINVAL;
592f1e547c7SEvan Lojewski } else if ((offset + cur->size) > context->backend.flash_size) {
593f593b1bdSAndrew Jeffery /*
594f593b1bdSAndrew Jeffery * There is V1 skiboot implementations out there which don't
595f593b1bdSAndrew Jeffery * mask offset with window size, meaning when we have
596f593b1bdSAndrew Jeffery * window size == flash size we will never allow the host to
597f593b1bdSAndrew Jeffery * open a window except at 0x0, which isn't always where the
598f593b1bdSAndrew Jeffery * host requests it. Thus we have to ignore this check and just
599f593b1bdSAndrew Jeffery * hope the host doesn't access past the end of the window
600f593b1bdSAndrew Jeffery * (which it shouldn't) for V1 implementations to get around
601f593b1bdSAndrew Jeffery * this.
602f593b1bdSAndrew Jeffery */
603f593b1bdSAndrew Jeffery if (context->version == API_VERSION_1) {
604f1e547c7SEvan Lojewski cur->size = align_down(context->backend.flash_size - offset,
605f1e547c7SEvan Lojewski 1 << context->backend.block_size_shift);
606f593b1bdSAndrew Jeffery } else {
607f593b1bdSAndrew Jeffery /*
608f593b1bdSAndrew Jeffery * Allow requests to exceed the flash size, but limit
609f593b1bdSAndrew Jeffery * the response to the size of the flash.
610f593b1bdSAndrew Jeffery */
611f1e547c7SEvan Lojewski cur->size = context->backend.flash_size - offset;
612f593b1bdSAndrew Jeffery }
613f593b1bdSAndrew Jeffery }
614f593b1bdSAndrew Jeffery
615f593b1bdSAndrew Jeffery /* Copy from flash into the window buffer */
6160297e5b8SAndrew Jeffery rc = backend_copy(&context->backend, offset, cur->mem, cur->size);
617f593b1bdSAndrew Jeffery if (rc < 0) {
618f593b1bdSAndrew Jeffery /* We don't know how much we've copied -> better reset window */
6195dc9f959SAndrew Jeffery window_reset(context, cur);
620f593b1bdSAndrew Jeffery return rc;
621f593b1bdSAndrew Jeffery }
622f593b1bdSAndrew Jeffery /*
623f593b1bdSAndrew Jeffery * rc isn't guaranteed to be aligned, so align up
624f593b1bdSAndrew Jeffery *
625f593b1bdSAndrew Jeffery * FIXME: This should only be the case for the vpnor ToC now, so handle
626f593b1bdSAndrew Jeffery * it there
627f593b1bdSAndrew Jeffery */
628f1e547c7SEvan Lojewski cur->size = align_up(rc, (1ULL << context->backend.block_size_shift));
629f593b1bdSAndrew Jeffery /* Would like a known value, pick 0xFF to it looks like erased flash */
630f593b1bdSAndrew Jeffery memset(cur->mem + rc, 0xFF, cur->size - rc);
631f593b1bdSAndrew Jeffery
632f593b1bdSAndrew Jeffery /*
633f593b1bdSAndrew Jeffery * Since for V1 windows aren't constrained to start at multiples of
634f593b1bdSAndrew Jeffery * window size it's possible that something already maps this offset.
635f593b1bdSAndrew Jeffery * Reset any windows which map this offset to avoid coherency problems.
636f593b1bdSAndrew Jeffery * We just have to check for anything which maps the start or the end
637f593b1bdSAndrew Jeffery * of the window since all windows are the same size so another window
638f593b1bdSAndrew Jeffery * cannot map just the middle of this window.
639f593b1bdSAndrew Jeffery */
640f593b1bdSAndrew Jeffery if (context->version == API_VERSION_1) {
641f593b1bdSAndrew Jeffery uint32_t i;
642f593b1bdSAndrew Jeffery
643f593b1bdSAndrew Jeffery MSG_DBG("Checking for window overlap\n");
644f593b1bdSAndrew Jeffery
645f593b1bdSAndrew Jeffery for (i = offset; i < (offset + cur->size); i += (cur->size - 1)) {
646f593b1bdSAndrew Jeffery struct window_context *tmp = NULL;
647f593b1bdSAndrew Jeffery do {
64817c477a7SAndrew Jeffery tmp = windows_search(context, i, false);
649f593b1bdSAndrew Jeffery if (tmp) {
6505dc9f959SAndrew Jeffery window_reset(context, tmp);
651f593b1bdSAndrew Jeffery }
652f593b1bdSAndrew Jeffery } while (tmp);
653f593b1bdSAndrew Jeffery }
654f593b1bdSAndrew Jeffery }
655f593b1bdSAndrew Jeffery
656f593b1bdSAndrew Jeffery /* Clear the bytemap of the window just loaded -> we know it's clean */
6577d5ada63SAndrew Jeffery window_set_bytemap(context, cur, 0,
658f1e547c7SEvan Lojewski cur->size >> context->backend.block_size_shift,
659f593b1bdSAndrew Jeffery WINDOW_CLEAN);
660f593b1bdSAndrew Jeffery
661f593b1bdSAndrew Jeffery /* Update so we know what's in the window */
662f593b1bdSAndrew Jeffery cur->flash_offset = offset;
663f593b1bdSAndrew Jeffery cur->age = ++(context->windows.max_age);
664f593b1bdSAndrew Jeffery *this_window = cur;
665f593b1bdSAndrew Jeffery
666f593b1bdSAndrew Jeffery return 0;
667f593b1bdSAndrew Jeffery }
668*68a24c9eSPatrick Williams
669*68a24c9eSPatrick Williams #pragma GCC diagnostic pop
670