sys/dev/drm/include/drm/drm_os_linux.h

   1 /**
   2  * \file drm_os_freebsd.h
   3  * OS abstraction macros.
   4  *
   5  * $FreeBSD: head/sys/dev/drm2/drm_os_freebsd.h 254858 2013-08-25 14:27:14Z dumbbell $
   6  */
   7
   8 #include <sys/endian.h>
   9
  10 #define DRM_READ8(map, offset)                                          \
  11         *(volatile u_int8_t *)(((vm_offset_t)(map)->handle) +           \
  12             (vm_offset_t)(offset))
  13 #define DRM_READ16(map, offset)                                         \
  14         le16toh(*(volatile u_int16_t *)(((vm_offset_t)(map)->handle) +  \
  15             (vm_offset_t)(offset)))
  16 #define DRM_READ32(map, offset)                                         \
  17         le32toh(*(volatile u_int32_t *)(((vm_offset_t)(map)->handle) +  \
  18             (vm_offset_t)(offset)))
  19 #define DRM_READ64(map, offset)                                         \
  20         le64toh(*(volatile u_int64_t *)(((vm_offset_t)(map)->handle) +  \
  21             (vm_offset_t)(offset)))
  22 #define DRM_WRITE8(map, offset, val)                                    \
  23         *(volatile u_int8_t *)(((vm_offset_t)(map)->handle) +           \
  24             (vm_offset_t)(offset)) = val
  25 #define DRM_WRITE16(map, offset, val)                                   \
  26         *(volatile u_int16_t *)(((vm_offset_t)(map)->handle) +          \
  27             (vm_offset_t)(offset)) = htole16(val)
  28
  29 #define DRM_WRITE32(map, offset, val)                                   \
  30         *(volatile u_int32_t *)(((vm_offset_t)(map)->handle) +          \
  31             (vm_offset_t)(offset)) = htole32(val)
  32
  33 #define DRM_WRITE64(map, offset, val)                                   \
  34         *(volatile u_int64_t *)(((vm_offset_t)(map)->handle) +          \
  35             (vm_offset_t)(offset)) = htole64(val)
  36
  37
  38 #if _BYTE_ORDER == _BIG_ENDIAN
  39 #define __BIG_ENDIAN 4321
  40 #else
  41 #define __LITTLE_ENDIAN 1234
  42 #endif
  43
  44 #ifdef __LP64__
  45 #define BITS_PER_LONG   64
  46 #else
  47 #define BITS_PER_LONG   32
  48 #endif
  49
  50 #define cpu_to_le16(x)  htole16(x)
  51 #define le16_to_cpu(x)  le16toh(x)
  52 #define cpu_to_le32(x)  htole32(x)
  53 #define le32_to_cpu(x)  le32toh(x)
  54
  55 #define cpu_to_be16(x)  htobe16(x)
  56 #define be16_to_cpu(x)  be16toh(x)
  57 #define cpu_to_be32(x)  htobe32(x)
  58 #define be32_to_cpu(x)  be32toh(x)
  59 #define be32_to_cpup(x) be32toh(*x)
  60
  61 #define unlikely(x)            __builtin_expect(!!(x), 0)
  62 #define likely(x)              __builtin_expect(!!(x), 1)
  63
  64 #define DRM_HZ                  hz
  65 #define DRM_UDELAY(udelay)      DELAY(udelay)
  66 #define DRM_MDELAY(msecs)       do { int loops = (msecs);               \
  67                                   while (loops--) DELAY(1000);          \
  68                                 } while (0)
  69 #define DRM_TIME_SLICE          (hz/20)  /* Time slice for GLXContexts    */
  70
  71 #define lower_32_bits(n)        ((u32)(n))
  72
  73 #define memset_io(a, b, c)      memset((a), (b), (c))
  74 #define memcpy_fromio(a, b, c)  memcpy((a), (b), (c))
  75 #define memcpy_toio(a, b, c)    memcpy((a), (b), (c))
  76
  77 /* XXXKIB what is the right code for the FreeBSD ? */
  78 /* kib@ used ENXIO here -- dumbbell@ */
  79 #define EREMOTEIO       EIO
  80
  81 #define KTR_DRM         KTR_DEV
  82 #define KTR_DRM_REG     KTR_SPARE3
  83
  84 #define hweight32(i)    bitcount32(i)
  85
  86 /**
  87  * ror32 - rotate a 32-bit value right
  88  * @word: value to rotate
  89  * @shift: bits to roll
  90  *
  91  * Source: include/linux/bitops.h
  92  */
  93 static inline uint32_t ror32(uint32_t word, unsigned int shift)
  94 {
  95         return (word >> shift) | (word << (32 - shift));
  96 }
  97
  98 #define IS_ALIGNED(x, y)        (((x) & ((y) - 1)) == 0)
  99 #define get_unaligned(ptr)                                              \
 100         ({ __typeof__(*(ptr)) __tmp;                                    \
 101           memcpy(&__tmp, (ptr), sizeof(*(ptr))); __tmp; })
 102
 103 #if _BYTE_ORDER == _LITTLE_ENDIAN
 104 /* Taken from linux/include/linux/unaligned/le_struct.h. */
 105 struct __una_u32 { u32 x; } __packed;
 106
 107 static inline u32 __get_unaligned_cpu32(const void *p)
 108 {
 109         const struct __una_u32 *ptr = (const struct __una_u32 *)p;
 110         return ptr->x;
 111 }
 112
 113 static inline u32 get_unaligned_le32(const void *p)
 114 {
 115         return __get_unaligned_cpu32((const u8 *)p);
 116 }
 117 #else
 118 /* Taken from linux/include/linux/unaligned/le_byteshift.h. */
 119 static inline u32 __get_unaligned_le32(const u8 *p)
 120 {
 121         return p[0] | p[1] << 8 | p[2] << 16 | p[3] << 24;
 122 }
 123
 124 static inline u32 get_unaligned_le32(const void *p)
 125 {
 126         return __get_unaligned_le32((const u8 *)p);
 127 }
 128 #endif
 129
 130 #define KIB_NOTYET()                                                    \
 131 do {                                                                    \
 132         if (drm_debug && drm_notyet_flag)                               \
 133                 kprintf("NOTYET: %s at %s:%d\n", __func__, __FILE__, __LINE__); \
 134 } while (0)