summaryrefslogtreecommitdiff
path: root/src
diff options
context:
space:
mode:
authorAaron Durbin <adurbin@chromium.org>2015-09-17 11:24:08 -0500
committerAaron Durbin <adurbin@chromium.org>2015-09-22 21:21:56 +0000
commitf66a026d70961832164ca4edd701d762384786b3 (patch)
tree7900ace2d2752de0438002a0185f33f4f3354a3e /src
parentdc9f5cd54661e5ba3fffee7af0ba17dde9367b95 (diff)
downloadcoreboot-f66a026d70961832164ca4edd701d762384786b3.tar.xz
commonlib: add endian related accessor functions
This commit adds read/write functions for both big and little endian interpretations. Additionally there are variants that allow an offset to be provided into the source buffer. BUG=None TEST=Wrote test harness for functions. Also booted ARM QEMU through end of payload. Change-Id: If44c4d489f0dab86a73b73580c039e364c7e517d Signed-off-by: Aaron Durbin <adurbin@chromium.org> Reviewed-on: http://review.coreboot.org/11677 Tested-by: build bot (Jenkins) Reviewed-by: Alexandru Gagniuc <mr.nuke.me@gmail.com>
Diffstat (limited to 'src')
-rw-r--r--src/commonlib/include/commonlib/endian.h261
1 files changed, 261 insertions, 0 deletions
diff --git a/src/commonlib/include/commonlib/endian.h b/src/commonlib/include/commonlib/endian.h
new file mode 100644
index 0000000000..bcd3b39c6f
--- /dev/null
+++ b/src/commonlib/include/commonlib/endian.h
@@ -0,0 +1,261 @@
+/*
+ * This file is part of the coreboot project.
+ *
+ * Copyright 2015 Google Inc.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; version 2 of the License.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc.
+ */
+
+#ifndef _COMMONLIB_ENDIAN_H_
+#define _COMMONLIB_ENDIAN_H_
+
+#include <stddef.h>
+#include <stdint.h>
+
+/* Endian agnostic functions working on single byte. */
+
+static inline uint8_t read_ble8(const void *src)
+{
+ const uint8_t *s = src;
+ return *s;
+}
+
+static inline uint8_t read_at_ble8(const void *src, size_t offset)
+{
+ const uint8_t *s = src;
+ s += offset;
+ return read_ble8(s);
+}
+
+static inline void write_ble8(void *dest, uint8_t val)
+{
+ *(uint8_t *)dest = val;
+}
+
+static inline void write_at_ble8(void *dest, uint8_t val, size_t offset)
+{
+ uint8_t *d = dest;
+ d += offset;
+ write_ble8(d, val);
+}
+
+/* Big Endian functions. */
+
+static inline uint8_t read_be8(const void *src)
+{
+ return read_ble8(src);
+}
+
+static inline uint8_t read_at_be8(const void *src, size_t offset)
+{
+ return read_at_ble8(src, offset);
+}
+
+static inline void write_be8(void *dest, uint8_t val)
+{
+ write_ble8(dest, val);
+}
+
+static inline void write_at_be8(void *dest, uint8_t val, size_t offset)
+{
+ write_at_ble8(dest, val, offset);
+}
+
+static inline uint16_t read_be16(const void *src)
+{
+ const uint8_t *s = src;
+ return (((uint16_t)s[0]) << 8) | (((uint16_t)s[1]) << 0);
+}
+
+static inline uint16_t read_at_be16(const void *src, size_t offset)
+{
+ const uint8_t *s = src;
+ s += offset;
+ return read_be16(s);
+}
+
+static inline void write_be16(void *dest, uint16_t val)
+{
+ write_be8(dest, val >> 8);
+ write_at_be8(dest, val >> 0, sizeof(uint8_t));
+}
+
+static inline void write_at_be16(void *dest, uint16_t val, size_t offset)
+{
+ uint8_t *d = dest;
+ d += offset;
+ write_be16(d, val);
+}
+
+static inline uint32_t read_be32(const void *src)
+{
+ const uint8_t *s = src;
+ return (((uint32_t)s[0]) << 24) | (((uint32_t)s[1]) << 16) |
+ (((uint32_t)s[2]) << 8) | (((uint32_t)s[3]) << 0);
+}
+
+static inline uint32_t read_at_be32(const void *src, size_t offset)
+{
+ const uint8_t *s = src;
+ s += offset;
+ return read_be32(s);
+}
+
+static inline void write_be32(void *dest, uint32_t val)
+{
+ write_be16(dest, val >> 16);
+ write_at_be16(dest, val >> 0, sizeof(uint16_t));
+}
+
+static inline void write_at_be32(void *dest, uint32_t val, size_t offset)
+{
+ uint8_t *d = dest;
+ d += offset;
+ write_be32(d, val);
+}
+
+static inline uint64_t read_be64(const void *src)
+{
+ uint64_t val;
+ val = read_be32(src);
+ val <<= 32;
+ val |= read_at_be32(src, sizeof(uint32_t));
+ return val;
+}
+
+static inline uint64_t read_at_be64(const void *src, size_t offset)
+{
+ const uint8_t *s = src;
+ s += offset;
+ return read_be64(s);
+}
+
+static inline void write_be64(void *dest, uint64_t val)
+{
+ write_be32(dest, val >> 32);
+ write_at_be32(dest, val >> 0, sizeof(uint32_t));
+}
+
+static inline void write_at_be64(void *dest, uint64_t val, size_t offset)
+{
+ uint8_t *d = dest;
+ d += offset;
+ write_be64(d, val);
+}
+
+/* Little Endian functions. */
+
+static inline uint8_t read_le8(const void *src)
+{
+ return read_ble8(src);
+}
+
+static inline uint8_t read_at_le8(const void *src, size_t offset)
+{
+ return read_at_ble8(src, offset);
+}
+
+static inline void write_le8(void *dest, uint8_t val)
+{
+ write_ble8(dest, val);
+}
+
+static inline void write_at_le8(void *dest, uint8_t val, size_t offset)
+{
+ write_at_ble8(dest, val, offset);
+}
+
+static inline uint16_t read_le16(const void *src)
+{
+ const uint8_t *s = src;
+ return (((uint16_t)s[1]) << 8) | (((uint16_t)s[0]) << 0);
+}
+
+static inline uint16_t read_at_le16(const void *src, size_t offset)
+{
+ const uint8_t *s = src;
+ s += offset;
+ return read_le16(s);
+}
+
+static inline void write_le16(void *dest, uint16_t val)
+{
+ write_le8(dest, val >> 0);
+ write_at_le8(dest, val >> 8, sizeof(uint8_t));
+}
+
+static inline void write_at_le16(void *dest, uint16_t val, size_t offset)
+{
+ uint8_t *d = dest;
+ d += offset;
+ write_le16(d, val);
+}
+
+static inline uint32_t read_le32(const void *src)
+{
+ const uint8_t *s = src;
+ return (((uint32_t)s[3]) << 24) | (((uint32_t)s[2]) << 16) |
+ (((uint32_t)s[1]) << 8) | (((uint32_t)s[0]) << 0);
+}
+
+static inline uint32_t read_at_le32(const void *src, size_t offset)
+{
+ const uint8_t *s = src;
+ s += offset;
+ return read_le32(s);
+}
+
+static inline void write_le32(void *dest, uint32_t val)
+{
+ write_le16(dest, val >> 0);
+ write_at_le16(dest, val >> 16, sizeof(uint16_t));
+}
+
+static inline void write_at_le32(void *dest, uint32_t val, size_t offset)
+{
+ uint8_t *d = dest;
+ d += offset;
+ write_le32(d, val);
+}
+
+static inline uint64_t read_le64(const void *src)
+{
+ uint64_t val;
+ val = read_at_le32(src, sizeof(uint32_t));
+ val <<= 32;
+ val |= read_le32(src);
+ return val;
+}
+
+static inline uint64_t read_at_le64(const void *src, size_t offset)
+{
+ const uint8_t *s = src;
+ s += offset;
+ return read_le64(s);
+}
+
+static inline void write_le64(void *dest, uint64_t val)
+{
+ write_le32(dest, val >> 0);
+ write_at_le32(dest, val >> 32, sizeof(uint32_t));
+}
+
+static inline void write_at_le64(void *dest, uint64_t val, size_t offset)
+{
+ uint8_t *d = dest;
+ d += offset;
+ write_le64(d, val);
+}
+
+#endif