1/*
  2 *  Port on Texas Instruments TMS320C6x architecture
  3 *
  4 *  Copyright (C) 2004, 2009, 2010 Texas Instruments Incorporated
  5 *  Author: Aurelien Jacquiot (aurelien.jacquiot@jaluna.com)
  6 *  Rewritten for 2.6.3x: Mark Salter <msalter@redhat.com>
  7 *
  8 *  This program is free software; you can redistribute it and/or modify
  9 *  it under the terms of the GNU General Public License version 2 as
 10 *  published by the Free Software Foundation.
 11 */
 12#ifndef _ASM_C6X_UNALIGNED_H
 13#define _ASM_C6X_UNALIGNED_H
 14
 15#include <linux/swab.h>
 16
 17/*
 18 * The C64x+ can do unaligned word and dword accesses in hardware
 19 * using special load/store instructions.
 20 */
 21
 22static inline u16 get_unaligned_le16(const void *p)
 23{
 24	const u8 *_p = p;
 25	return _p[0] | _p[1] << 8;
 26}
 27
 28static inline u16 get_unaligned_be16(const void *p)
 29{
 30	const u8 *_p = p;
 31	return _p[0] << 8 | _p[1];
 32}
 33
 34static inline void put_unaligned_le16(u16 val, void *p)
 35{
 36	u8 *_p = p;
 37	_p[0] = val;
 38	_p[1] = val >> 8;
 39}
 40
 41static inline void put_unaligned_be16(u16 val, void *p)
 42{
 43	u8 *_p = p;
 44	_p[0] = val >> 8;
 45	_p[1] = val;
 46}
 47
 48static inline u32 get_unaligned32(const void *p)
 49{
 50	u32 val = (u32) p;
 51	asm (" ldnw	.d1t1	*%0,%0\n"
 52	     " nop     4\n"
 53	     : "+a"(val));
 54	return val;
 55}
 56
 57static inline void put_unaligned32(u32 val, void *p)
 58{
 59	asm volatile (" stnw	.d2t1	%0,*%1\n"
 60		      : : "a"(val), "b"(p) : "memory");
 61}
 62
 63static inline u64 get_unaligned64(const void *p)
 64{
 65	u64 val;
 66	asm volatile (" ldndw	.d1t1	*%1,%0\n"
 67		      " nop     4\n"
 68		      : "=a"(val) : "a"(p));
 69	return val;
 70}
 71
 72static inline void put_unaligned64(u64 val, const void *p)
 73{
 74	asm volatile (" stndw	.d2t1	%0,*%1\n"
 75		      : : "a"(val), "b"(p) : "memory");
 76}
 77
 78#ifdef CONFIG_CPU_BIG_ENDIAN
 79
 80#define get_unaligned_le32(p)	 __swab32(get_unaligned32(p))
 81#define get_unaligned_le64(p)	 __swab64(get_unaligned64(p))
 82#define get_unaligned_be32(p)	 get_unaligned32(p)
 83#define get_unaligned_be64(p)	 get_unaligned64(p)
 84#define put_unaligned_le32(v, p) put_unaligned32(__swab32(v), (p))
 85#define put_unaligned_le64(v, p) put_unaligned64(__swab64(v), (p))
 86#define put_unaligned_be32(v, p) put_unaligned32((v), (p))
 87#define put_unaligned_be64(v, p) put_unaligned64((v), (p))
 88#define get_unaligned	__get_unaligned_be
 89#define put_unaligned	__put_unaligned_be
 90
 91#else
 92
 93#define get_unaligned_le32(p)	 get_unaligned32(p)
 94#define get_unaligned_le64(p)	 get_unaligned64(p)
 95#define get_unaligned_be32(p)	 __swab32(get_unaligned32(p))
 96#define get_unaligned_be64(p)	 __swab64(get_unaligned64(p))
 97#define put_unaligned_le32(v, p) put_unaligned32((v), (p))
 98#define put_unaligned_le64(v, p) put_unaligned64((v), (p))
 99#define put_unaligned_be32(v, p) put_unaligned32(__swab32(v), (p))
100#define put_unaligned_be64(v, p) put_unaligned64(__swab64(v), (p))
101#define get_unaligned	__get_unaligned_le
102#define put_unaligned	__put_unaligned_le
103
104#endif
105
106/*
107 * Cause a link-time error if we try an unaligned access other than
108 * 1,2,4 or 8 bytes long
109 */
110extern int __bad_unaligned_access_size(void);
111
112#define __get_unaligned_le(ptr) (typeof(*(ptr)))({			\
113	sizeof(*(ptr)) == 1 ? *(ptr) :					\
114	  (sizeof(*(ptr)) == 2 ? get_unaligned_le16((ptr)) :		\
115	     (sizeof(*(ptr)) == 4 ? get_unaligned_le32((ptr)) :		\
116		(sizeof(*(ptr)) == 8 ? get_unaligned_le64((ptr)) :	\
117		   __bad_unaligned_access_size())));			\
118	})
119
120#define __get_unaligned_be(ptr) (__force typeof(*(ptr)))({	\
121	sizeof(*(ptr)) == 1 ? *(ptr) :					\
122	  (sizeof(*(ptr)) == 2 ? get_unaligned_be16((ptr)) :		\
123	     (sizeof(*(ptr)) == 4 ? get_unaligned_be32((ptr)) :		\
124		(sizeof(*(ptr)) == 8 ? get_unaligned_be64((ptr)) :	\
125		   __bad_unaligned_access_size())));			\
126	})
127
128#define __put_unaligned_le(val, ptr) ({					\
129	void *__gu_p = (ptr);						\
130	switch (sizeof(*(ptr))) {					\
131	case 1:								\
132		*(u8 *)__gu_p = (__force u8)(val);			\
133		break;							\
134	case 2:								\
135		put_unaligned_le16((__force u16)(val), __gu_p);		\
136		break;							\
137	case 4:								\
138		put_unaligned_le32((__force u32)(val), __gu_p);		\
139		break;							\
140	case 8:								\
141		put_unaligned_le64((__force u64)(val), __gu_p);		\
142		break;							\
143	default:							\
144		__bad_unaligned_access_size();				\
145		break;							\
146	}								\
147	(void)0; })
148
149#define __put_unaligned_be(val, ptr) ({					\
150	void *__gu_p = (ptr);						\
151	switch (sizeof(*(ptr))) {					\
152	case 1:								\
153		*(u8 *)__gu_p = (__force u8)(val);			\
154		break;							\
155	case 2:								\
156		put_unaligned_be16((__force u16)(val), __gu_p);		\
157		break;							\
158	case 4:								\
159		put_unaligned_be32((__force u32)(val), __gu_p);		\
160		break;							\
161	case 8:								\
162		put_unaligned_be64((__force u64)(val), __gu_p);		\
163		break;							\
164	default:							\
165		__bad_unaligned_access_size();				\
166		break;							\
167	}								\
168	(void)0; })
169
170#endif /* _ASM_C6X_UNALIGNED_H */