vboot: new streaming APIs

This patch adds three functions called from vboot into depthcharge to
support NAND. NAND needs to stream rather than be accessed randomly
in order to skip bad blocks. The intended flow from vboot1 is:
- Read the GPT from a NAND disk handle, and depthcharge will silently
  fill it in with reads from from SPI
- When a partition is selected, open a stream on the volume to access
  NAND
- Sequentially read the NAND partition
- Close the NAND stream
This can be done multiple times when trying different partitions. The
stream is associated with the GPT by reading/opening a stream from the
same disk handle.

This patch includes stub implementations by rspangler to translate the
stream calls to block device calls.

To reduce vboot code duplication, this flow will be done for all media
types eventually, but a STREAMING flag is included to ease the transition.
The draft depthcharge code can be found at
https://chromium-review.googlesource.com/#/c/222312/

BUG=chromium:403432
TEST=stub implementations pass unit tests; together with upcoming depthcharge
and vboot code, actually boots a kernel. This compiles by itself.
BRANCH=none

Change-Id: I660a89594390c72c2ef6ea2564367ce62bd90cf2
Reviewed-on: https://chromium-review.googlesource.com/221992
Reviewed-by: Randall Spangler <rspangler@chromium.org>
Reviewed-by: Daniel Ehrenberg <dehrenberg@chromium.org>
Tested-by: Randall Spangler <rspangler@chromium.org>
Commit-Queue: Randall Spangler <rspangler@chromium.org>

1 files changed, 87 insertions, 0 deletions

diff --git a/firmware/stub/vboot_api_stub_stream.c b/firmware/stub/vboot_api_stub_stream.c
new file mode 100644
index 00000000..525c8f78
--- /dev/null
+++ b/firmware/stub/vboot_api_stub_stream.c
@@ -0,0 +1,87 @@
+/* Copyright (c) 2014 The Chromium OS Authors. All rights reserved.
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ *
+ * Stub implementations of stream APIs.
+ */
+
+#include <stdint.h>
+
+#define _STUB_IMPLEMENTATION_
+
+#include "vboot_api.h"
+
+/* The stub implementation assumes 512-byte disk sectors */
+#define LBA_BYTES 512
+
+/* Internal struct to simulate a stream for sector-based disks */
+struct disk_stream {
+	/* Disk handle */
+	VbExDiskHandle_t handle;
+
+	/* Next sector to read */
+	uint64_t sector;
+
+	/* Number of sectors left in partition */
+	uint64_t sectors_left;
+};
+
+VbError_t VbExStreamOpen(VbExDiskHandle_t handle, uint64_t lba_start,
+			 uint64_t lba_count, VbExStream_t *stream)
+{
+	struct disk_stream *s;
+
+	if (!handle) {
+		*stream = NULL;
+		return VBERROR_UNKNOWN;
+	}
+
+	s = VbExMalloc(sizeof(*s));
+	s->handle = handle;
+	s->sector = lba_start;
+	s->sectors_left = lba_count;
+
+	*stream = (void *)s;
+
+	return VBERROR_SUCCESS;
+}
+
+VbError_t VbExStreamRead(VbExStream_t stream, uint32_t bytes, void *buffer)
+{
+	struct disk_stream *s = (struct disk_stream *)stream;
+	uint64_t sectors;
+	VbError_t rv;
+
+	if (!s)
+		return VBERROR_UNKNOWN;
+
+	/* For now, require reads to be a multiple of the LBA size */
+	if (bytes % LBA_BYTES)
+		return VBERROR_UNKNOWN;
+
+	/* Fail on overflow */
+	sectors = bytes / LBA_BYTES;
+	if (sectors > s->sectors_left)
+		return VBERROR_UNKNOWN;
+
+	rv = VbExDiskRead(s->handle, s->sector, sectors, buffer);
+	if (rv != VBERROR_SUCCESS)
+		return rv;
+
+	s->sector += sectors;
+	s->sectors_left -= sectors;
+
+	return VBERROR_SUCCESS;
+}
+
+void VbExStreamClose(VbExStream_t stream)
+{
+	struct disk_stream *s = (struct disk_stream *)stream;
+
+	/* Allow freeing a null pointer */
+	if (!s)
+		return;
+
+	VbExFree(s);
+	return;
+}