carl9170fw/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 volatile void *readp(const volatile void *addr)
  35 {
  36         return *(volatile void **) addr;
  37 }
  38
  39 static inline __inline uint32_t readl(const volatile void *addr)
  40 {
  41         return *(const volatile unsigned int *) 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         do {
  85                 tmp = read;
  86                 tmp = readl(addr);
  87                 i++;
  88         } while (tmp != read && i <= 10);
  89
  90         return read;
  91 }
  92
  93 static inline __inline void set(const volatile uint32_t addr, const volatile uint32_t val)
  94 {
  95         writel((volatile void *) addr, val);
  96 }
  97
  98 static inline __inline void orl(volatile uint32_t addr, const volatile uint32_t val)
  99 {
 100         __orl((volatile void *) addr, val);
 101 }
 102
 103 static inline __inline void xorl(const volatile uint32_t addr, const volatile uint32_t val)
 104 {
 105         __xorl((volatile void *) addr, val);
 106 }
 107
 108 static inline __inline void andl(const volatile uint32_t addr, const volatile uint32_t val)
 109 {
 110         __andl((volatile void *) addr, val);
 111 }
 112
 113 static inline __inline void incl(const volatile uint32_t addr)
 114 {
 115         __incl((volatile void *) addr);
 116 }
 117
 118 static inline __inline uint32_t get(const volatile uint32_t addr)
 119 {
 120         return readl((volatile void *) addr);
 121 }
 122
 123 static inline __inline volatile void *getp(const volatile uint32_t addr)
 124 {
 125         return readp((const volatile void *) addr);
 126 }
 127
 128 static inline __inline uint32_t get_async(const volatile uint32_t addr)
 129 {
 130         return readl_async((const volatile void *) addr);
 131 }
 132
 133 static inline __inline void setb(const volatile uint32_t addr, const volatile uint8_t val)
 134 {
 135         writeb((volatile void *) addr, val);
 136 }
 137
 138 static inline __inline uint8_t getb(const volatile uint32_t addr)
 139 {
 140         return readb((const volatile void *) addr);
 141 }
 142
 143 static inline __inline void andb(const volatile uint32_t addr, const volatile uint8_t val)
 144 {
 145         setb(addr, getb(addr) & val);
 146 }
 147
 148 static inline __inline void orb(const volatile uint32_t addr, const volatile uint32_t val)
 149 {
 150         setb(addr, getb(addr) | val);
 151 }
 152
 153 #endif /* __CARL9170FW_IO_H */