X-Git-Url: https://review.openocd.org/gitweb?p=openocd.git;a=blobdiff_plain;f=src%2Fhelper%2Ftypes.h;h=210d3c3e92fd3d2f1354e8eb0066a41da9a703cd;hp=1010dcd967b6365f198ce9738ac431b6fcc11b8d;hb=4516eebabac0df24f00f40ff97ff570fdd39b2db;hpb=60cb5bdd30ec3265cbb5c1c667f5c98cbbb84aab

diff --git a/src/helper/types.h b/src/helper/types.h
index 1010dcd967..210d3c3e92 100644
--- a/src/helper/types.h
+++ b/src/helper/types.h
@@ -18,7 +18,7 @@
  *   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.,                                       *
- *   59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.             *
+ *   51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.           *
  ***************************************************************************/
 #ifndef TYPES_H
 #define TYPES_H
@@ -80,7 +80,7 @@ typedef bool _Bool;
  */
 #define container_of(ptr, type, member) ({			\
 	const typeof( ((type *)0)->member ) *__mptr = (ptr);	\
-	(type *)( (char *)__mptr - offsetof(type,member) );})
+	(type *)( (void *) ( (char *)__mptr - offsetof(type,member) ) );})
 
 
 /**
@@ -110,27 +110,84 @@ typedef bool _Bool;
  * Again, note that the "buf" pointer in memory is probably unaligned.
  */
 
+static inline uint64_t le_to_h_u64(const uint8_t *buf)
+{
+	return (uint64_t)((uint64_t)buf[0] |
+			  (uint64_t)buf[1] << 8 |
+			  (uint64_t)buf[2] << 16 |
+			  (uint64_t)buf[3] << 24 |
+			  (uint64_t)buf[4] << 32 |
+			  (uint64_t)buf[5] << 40 |
+			  (uint64_t)buf[6] << 48 |
+			  (uint64_t)buf[7] << 56);
+}
 
 static inline uint32_t le_to_h_u32(const uint8_t* buf)
 {
 	return (uint32_t)(buf[0] | buf[1] << 8 | buf[2] << 16 | buf[3] << 24);
 }
 
+static inline uint32_t le_to_h_u24(const uint8_t* buf)
+{
+	return (uint32_t)(buf[0] | buf[1] << 8 | buf[2] << 16);
+}
+
 static inline uint16_t le_to_h_u16(const uint8_t* buf)
 {
 	return (uint16_t)(buf[0] | buf[1] << 8);
 }
 
+static inline uint64_t be_to_h_u64(const uint8_t *buf)
+{
+	return (uint64_t)((uint64_t)buf[7] |
+			  (uint64_t)buf[6] << 8 |
+			  (uint64_t)buf[5] << 16 |
+			  (uint64_t)buf[4] << 24 |
+			  (uint64_t)buf[3] << 32 |
+			  (uint64_t)buf[2] << 40 |
+			  (uint64_t)buf[1] << 48 |
+			  (uint64_t)buf[0] << 56);
+}
+
 static inline uint32_t be_to_h_u32(const uint8_t* buf)
 {
 	return (uint32_t)(buf[3] | buf[2] << 8 | buf[1] << 16 | buf[0] << 24);
 }
 
+static inline uint32_t be_to_h_u24(const uint8_t* buf)
+{
+	return (uint32_t)(buf[2] | buf[1] << 8 | buf[0] << 16);
+}
+
 static inline uint16_t be_to_h_u16(const uint8_t* buf)
 {
 	return (uint16_t)(buf[1] | buf[0] << 8);
 }
 
+static inline void h_u64_to_le(uint8_t *buf, int64_t val)
+{
+	buf[7] = (uint8_t) (val >> 56);
+	buf[6] = (uint8_t) (val >> 48);
+	buf[5] = (uint8_t) (val >> 40);
+	buf[4] = (uint8_t) (val >> 32);
+	buf[3] = (uint8_t) (val >> 24);
+	buf[2] = (uint8_t) (val >> 16);
+	buf[1] = (uint8_t) (val >> 8);
+	buf[0] = (uint8_t) (val >> 0);
+}
+
+static inline void h_u64_to_be(uint8_t *buf, int64_t val)
+{
+	buf[0] = (uint8_t) (val >> 56);
+	buf[1] = (uint8_t) (val >> 48);
+	buf[2] = (uint8_t) (val >> 40);
+	buf[3] = (uint8_t) (val >> 32);
+	buf[4] = (uint8_t) (val >> 24);
+	buf[5] = (uint8_t) (val >> 16);
+	buf[6] = (uint8_t) (val >> 8);
+	buf[7] = (uint8_t) (val >> 0);
+}
+
 static inline void h_u32_to_le(uint8_t* buf, int val)
 {
 	buf[3] = (uint8_t) (val >> 24);
@@ -147,6 +204,20 @@ static inline void h_u32_to_be(uint8_t* buf, int val)
 	buf[3] = (uint8_t) (val >> 0);
 }
 
+static inline void h_u24_to_le(uint8_t* buf, int val)
+{
+	buf[2] = (uint8_t) (val >> 16);
+	buf[1] = (uint8_t) (val >> 8);
+	buf[0] = (uint8_t) (val >> 0);
+}
+
+static inline void h_u24_to_be(uint8_t* buf, int val)
+{
+	buf[0] = (uint8_t) (val >> 16);
+	buf[1] = (uint8_t) (val >> 8);
+	buf[2] = (uint8_t) (val >> 0);
+}
+
 static inline void h_u16_to_le(uint8_t* buf, int val)
 {
 	buf[1] = (uint8_t) (val >> 8);
@@ -159,6 +230,46 @@ static inline void h_u16_to_be(uint8_t* buf, int val)
 	buf[1] = (uint8_t) (val >> 0);
 }
 
+/**
+ * Byte-swap buffer 16-bit.
+ *
+ * Len must be even, dst and src must be either the same or non-overlapping.
+ *
+ * @param dst Destination buffer.
+ * @param src Source buffer.
+ * @param len Length of source (and destination) buffer, in bytes.
+ */
+static inline void buf_bswap16(uint8_t *dst, const uint8_t *src, size_t len)
+{
+	assert(len % 2 == 0);
+	assert(dst == src || dst + len <= src || src + len <= dst);
+
+	for (size_t n = 0; n < len; n += 2) {
+		uint16_t x = be_to_h_u16(src + n);
+		h_u16_to_le(dst + n, x);
+	}
+}
+
+/**
+ * Byte-swap buffer 32-bit.
+ *
+ * Len must be divisible by four, dst and src must be either the same or non-overlapping.
+ *
+ * @param dst Destination buffer.
+ * @param src Source buffer.
+ * @param len Length of source (and destination) buffer, in bytes.
+ */
+static inline void buf_bswap32(uint8_t *dst, const uint8_t *src, size_t len)
+{
+	assert(len % 4 == 0);
+	assert(dst == src || dst + len <= src || src + len <= dst);
+
+	for (size_t n = 0; n < len; n += 4) {
+		uint32_t x = be_to_h_u32(src + n);
+		h_u32_to_le(dst + n, x);
+	}
+}
+
 #if defined(__ECOS)
 
 /* eCos plain lacks these definition... A series of upstream patches
@@ -173,6 +284,8 @@ static inline void h_u16_to_be(uint8_t* buf, int val)
 #define PRIi32 "i"
 #define PRIu32 "u"
 #define PRId8 PRId32
+#define SCNx64 "llx"
+#define PRIx64 "llx"
 
 typedef CYG_ADDRWORD intptr_t;
 typedef int64_t intmax_t;
@@ -191,11 +304,11 @@ typedef uint64_t uintmax_t;
 #define UINT64_MAX (__CONCAT(INT64_MAX, U) * 2ULL + 1ULL)
 #endif
 
-    #ifndef LLONG_MAX
+	#ifndef LLONG_MAX
 	#define ULLONG_MAX	UINT64_C(0xFFFFFFFFFFFFFFFF)
 	#define LLONG_MAX	INT64_C(0x7FFFFFFFFFFFFFFF)
 	#define LLONG_MIN	ULLONG_MAX
-    #endif
+	#endif
 
 
 #define ULLONG_MAX 18446744073709551615