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, see <http://www.gnu.org/licenses/>.
  14  */
  15
  16 #ifndef __CARL9170FW_IO_H
  17 #define __CARL9170FW_IO_H
  18
  19 #include "config.h"
  20 #include "types.h"
  21 #include "compiler.h"
  22
  23 static inline __inline uint8_t readb(const volatile void *addr)
  24 {
  25         return *(const volatile uint8_t *) addr;
  26 }
  27
  28 static inline __inline uint16_t readw(const volatile void *addr)
  29 {
  30         return *(const volatile uint16_t *) addr;
  31 }
  32
  33 static inline __inline volatile void *readp(const volatile void *addr)
  34 {
  35         return *(volatile void **) addr;
  36 }
  37
  38 static inline __inline uint32_t readl(const volatile void *addr)
  39 {
  40         return *(const volatile unsigned int *) addr;
  41 }
  42
  43 static inline __inline void writeb(volatile void *addr, const volatile uint8_t val)
  44 {
  45         *(volatile uint8_t *) addr = val;
  46 }
  47
  48 static inline __inline void writew(volatile void *addr, const volatile uint16_t val)
  49 {
  50         *(volatile uint16_t *) addr = val;
  51 }
  52
  53 static inline __inline void writel(volatile void *addr, const volatile uint32_t val)
  54 {
  55         *(volatile uint32_t *) addr = val;
  56 }
  57
  58 static inline __inline void __orl(volatile void *addr, const volatile uint32_t val)
  59 {
  60         *(volatile uint32_t *) addr |= val;
  61 }
  62
  63 static inline __inline void __andl(volatile void *addr, const volatile uint32_t val)
  64 {
  65         *(volatile uint32_t *) addr &= val;
  66 }
  67
  68 static inline __inline void __xorl(volatile void *addr, const volatile uint32_t val)
  69 {
  70         *(volatile uint32_t *) addr ^= val;
  71 }
  72
  73 static inline __inline void __incl(volatile void *addr)
  74 {
  75         (*(volatile uint32_t *)addr)++;
  76 }
  77
  78 static inline __inline uint32_t readl_async(const volatile void *addr)
  79 {
  80         uint32_t i = 0, read, tmp;
  81
  82         read = readl(addr);
  83         do {
  84                 tmp = read;
  85                 tmp = readl(addr);
  86                 i++;
  87         } while (tmp != read && i <= 10);
  88
  89         return read;
  90 }
  91
  92 static inline __inline void set(const volatile uint32_t addr, const volatile uint32_t val)
  93 {
  94         writel((volatile void *) addr, val);
  95 }
  96
  97 static inline __inline void orl(volatile uint32_t addr, const volatile uint32_t val)
  98 {
  99         __orl((volatile void *) addr, val);
 100 }
 101
 102 static inline __inline void xorl(const volatile uint32_t addr, const volatile uint32_t val)
 103 {
 104         __xorl((volatile void *) addr, val);
 105 }
 106
 107 static inline __inline void andl(const volatile uint32_t addr, const volatile uint32_t val)
 108 {
 109         __andl((volatile void *) addr, val);
 110 }
 111
 112 static inline __inline void incl(const volatile uint32_t addr)
 113 {
 114         __incl((volatile void *) addr);
 115 }
 116
 117 static inline __inline uint32_t get(const volatile uint32_t addr)
 118 {
 119         return readl((volatile void *) addr);
 120 }
 121
 122 static inline __inline volatile void *getp(const volatile uint32_t addr)
 123 {
 124         return readp((const volatile void *) addr);
 125 }
 126
 127 static inline __inline uint32_t get_async(const volatile uint32_t addr)
 128 {
 129         return readl_async((const volatile void *) addr);
 130 }
 131
 132 static inline __inline void setb(const volatile uint32_t addr, const volatile uint8_t val)
 133 {
 134         writeb((volatile void *) addr, val);
 135 }
 136
 137 static inline __inline uint8_t getb(const volatile uint32_t addr)
 138 {
 139         return readb((const volatile void *) addr);
 140 }
 141
 142 static inline __inline void andb(const volatile uint32_t addr, const volatile uint8_t val)
 143 {
 144         setb(addr, getb(addr) & val);
 145 }
 146
 147 static inline __inline void orb(const volatile uint32_t addr, const volatile uint32_t val)
 148 {
 149         setb(addr, getb(addr) | val);
 150 }
 151
 152 static inline __inline uint16_t getw(const volatile uint32_t addr)
 153 {
 154         return readw((const volatile void *) addr);
 155 }
 156
 157 #endif /* __CARL9170FW_IO_H */