carlfw/include/io.h

   1 /*
   2  * This program is free software; you can redistribute it and/or modify
   3  * it under the terms of the GNU General Public License as published by
   4  * the Free Software Foundation; either version 2 of the License, or
   5  * (at your option) any later version.
   6  *
   7  * This program is distributed in the hope that it will be useful,
   8  * but WITHOUT ANY WARRANTY; without even the implied warranty of
   9  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  10  * GNU General Public License for more details.
  11  *
  12  * You should have received a copy of the GNU General Public License along
  13  * with this program; if not, write to the Free Software Foundation, Inc.,
  14  * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
  15  */
  16
  17 #ifndef __CARL9170FW_IO_H
  18 #define __CARL9170FW_IO_H
  19
  20 #include "config.h"
  21 #include "types.h"
  22 #include "compiler.h"
  23
  24 static inline __inline uint8_t readb(const volatile void *addr)
  25 {
  26         return *(const volatile uint8_t *) addr;
  27 }
  28
  29 static inline __inline uint16_t readw(const volatile void *addr)
  30 {
  31         return *(const volatile uint16_t *) addr;
  32 }
  33
  34 static inline __inline void *readp(const volatile void *addr)
  35 {
  36         return *(void **) addr;
  37 }
  38
  39 static inline __inline uint32_t readl(const volatile void *addr)
  40 {
  41         return (uint32_t) (const unsigned int *) readp(addr);
  42 }
  43
  44 static inline __inline void writeb(volatile void *addr, const volatile uint8_t val)
  45 {
  46         *(volatile uint8_t *) addr = val;
  47 }
  48
  49 static inline __inline void writew(volatile void *addr, const volatile uint16_t val)
  50 {
  51         *(volatile uint16_t *) addr = val;
  52 }
  53
  54 static inline __inline void writel(volatile void *addr, const volatile uint32_t val)
  55 {
  56         *(volatile uint32_t *) addr = val;
  57 }
  58
  59 static inline __inline void __orl(volatile void *addr, const volatile uint32_t val)
  60 {
  61         *(volatile uint32_t *) addr |= val;
  62 }
  63
  64 static inline __inline void __andl(volatile void *addr, const volatile uint32_t val)
  65 {
  66         *(volatile uint32_t *) addr &= val;
  67 }
  68
  69 static inline __inline void __xorl(volatile void *addr, const volatile uint32_t val)
  70 {
  71         *(volatile uint32_t *) addr ^= val;
  72 }
  73
  74 static inline __inline void __incl(volatile void *addr)
  75 {
  76         (*(volatile uint32_t *)addr)++;
  77 }
  78
  79 static inline __inline uint32_t readl_async(const volatile void *addr)
  80 {
  81         uint32_t i = 0, read, tmp;
  82
  83         read = readl(addr);
  84         while (i++ < 10) {
  85                 tmp = readl(addr);
  86                 if (tmp == read)
  87                         break;
  88                 else
  89                         read = tmp;
  90         }
  91
  92         return read;
  93 }
  94
  95 static inline __inline void set(const volatile uint32_t addr, const volatile uint32_t val)
  96 {
  97         writel((volatile void *) addr, val);
  98 }
  99
 100 static inline __inline void orl(volatile uint32_t addr, const volatile uint32_t val)
 101 {
 102         __orl((volatile void *) addr, val);
 103 }
 104
 105 static inline __inline void xorl(const volatile uint32_t addr, const volatile uint32_t val)
 106 {
 107         __xorl((volatile void *) addr, val);
 108 }
 109
 110 static inline __inline void andl(const volatile uint32_t addr, const volatile uint32_t val)
 111 {
 112         __andl((volatile void *) addr, val);
 113 }
 114
 115 static inline __inline void incl(const volatile uint32_t addr)
 116 {
 117         __incl((volatile void *) addr);
 118 }
 119
 120 static inline __inline uint32_t get(const volatile uint32_t addr)
 121 {
 122         return readl((const volatile void *) addr);
 123 }
 124
 125 static inline __inline void *getp(const volatile uint32_t addr)
 126 {
 127         return readp((const volatile void *) addr);
 128 }
 129
 130 static inline __inline uint32_t get_async(const volatile uint32_t addr)
 131 {
 132         return readl_async((const volatile void *) addr);
 133 }
 134
 135 static inline __inline void setb(const volatile uint32_t addr, const volatile uint8_t val)
 136 {
 137         writeb((volatile void *) addr, val);
 138 }
 139
 140 static inline __inline uint8_t getb(const volatile uint32_t addr)
 141 {
 142         return readb((const volatile void *) addr);
 143 }
 144
 145 static inline __inline void andb(const volatile uint32_t addr, const volatile uint8_t val)
 146 {
 147         setb(addr, getb(addr) & val);
 148 }
 149
 150 static inline __inline void orb(const volatile uint32_t addr, const volatile uint32_t val)
 151 {
 152         setb(addr, getb(addr) | val);
 153 }
 154
 155 #endif /* __CARL9170FW_IO_H */