include/asm-mips/unaligned.h

   1 /*
   2  * Inline functions to do unaligned accesses.
   3  *
   4  * This file is subject to the terms and conditions of the GNU General Public
   5  * License.  See the file "COPYING" in the main directory of this archive
   6  * for more details.
   7  *
   8  * Copyright (C) 1996 by Ralf Baechle
   9  */
  10 #ifndef __ASM_MIPS_UNALIGNED_H
  11 #define __ASM_MIPS_UNALIGNED_H
  12
  13 #include <asm/string.h>
  14
  15 /*
  16  * Load quad unaligned.
  17  */
  18 extern __inline__ unsigned long ldq_u(const unsigned long long * __addr)
  19 {
  20         unsigned long long __res;
  21
  22         __asm__("uld\t%0,(%1)"
  23                 :"=&r" (__res)
  24                 :"r" (__addr));
  25
  26         return __res;
  27 }
  28
  29 /*
  30  * Load long unaligned.
  31  */
  32 extern __inline__ unsigned long ldl_u(const unsigned int * __addr)
  33 {
  34         unsigned long __res;
  35
  36         __asm__("ulw\t%0,(%1)"
  37                 :"=&r" (__res)
  38                 :"r" (__addr));
  39
  40         return __res;
  41 }
  42
  43 /*
  44  * Load word unaligned.
  45  */
  46 extern __inline__ unsigned long ldw_u(const unsigned short * __addr)
  47 {
  48         unsigned long __res;
  49
  50         __asm__("ulh\t%0,(%1)"
  51                 :"=&r" (__res)
  52                 :"r" (__addr));
  53
  54         return __res;
  55 }
  56
  57 /*
  58  * Store quad ununaligned.
  59  */
  60 extern __inline__ void stq_u(unsigned long __val, unsigned long long * __addr)
  61 {
  62         __asm__ __volatile__(
  63                 "usd\t%0,(%1)"
  64                 : /* No results */
  65                 :"r" (__val),
  66                  "r" (__addr));
  67 }
  68
  69 /*
  70  * Store long ununaligned.
  71  */
  72 extern __inline__ void stl_u(unsigned long __val, unsigned int * __addr)
  73 {
  74         __asm__ __volatile__(
  75                 "usw\t%0,(%1)"
  76                 : /* No results */
  77                 :"r" (__val),
  78                  "r" (__addr));
  79 }
  80
  81 /*
  82  * Store word ununaligned.
  83  */
  84 extern __inline__ void stw_u(unsigned long __val, unsigned short * __addr)
  85 {
  86         __asm__ __volatile__(
  87                 "ush\t%0,(%1)"
  88                 : /* No results */
  89                 :"r" (__val),
  90                  "r" (__addr));
  91 }
  92
  93 extern inline unsigned long __get_unaligned(const void *ptr, size_t size)
  94 {
  95         unsigned long val;
  96         switch (size) {
  97               case 1:
  98                 val = *(const unsigned char *)ptr;
  99                 break;
 100               case 2:
 101                 val = ldw_u((const unsigned short *)ptr);
 102                 break;
 103               case 4:
 104                 val = ldl_u((const unsigned int *)ptr);
 105                 break;
 106               case 8:
 107                 val = ldq_u((const unsigned long long *)ptr);
 108                 break;
 109         }
 110         return val;
 111 }
 112
 113 extern inline void __put_unaligned(unsigned long val, void *ptr, size_t size)
 114 {
 115         switch (size) {
 116               case 1:
 117                 *(unsigned char *)ptr = (val);
 118                 break;
 119               case 2:
 120                 stw_u(val, (unsigned short *)ptr);
 121                 break;
 122               case 4:
 123                 stl_u(val, (unsigned int *)ptr);
 124                 break;
 125               case 8:
 126                 stq_u(val, (unsigned long long *)ptr);
 127                 break;
 128         }
 129 }
 130
 131 /*
 132  * The main single-value unaligned transfer routines.
 133  */
 134 #define get_unaligned(ptr) \
 135         ((__typeof__(*(ptr)))__get_unaligned((ptr), sizeof(*(ptr))))
 136 #define put_unaligned(x,ptr) \
 137         __put_unaligned((unsigned long)(x), (ptr), sizeof(*(ptr)))
 138
 139 #endif /* __ASM_MIPS_UNALIGNED_H */