hwaccess.c

   1 /*
   2  * This file is part of the flashrom project.
   3  *
   4  * Copyright (C) 2009,2010 Carl-Daniel Hailfinger
   5  *
   6  * This program is free software; you can redistribute it and/or modify
   7  * it under the terms of the GNU General Public License as published by
   8  * the Free Software Foundation; either version 2 of the License, or
   9  * (at your option) any later version.
  10  *
  11  * This program is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14  * GNU General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU General Public License
  17  * along with this program; if not, write to the Free Software
  18  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301 USA
  19  */
  20
  21 #include <stdint.h>
  22 #include <string.h>
  23 #include <stdlib.h>
  24 #include <sys/types.h>
  25 #if !defined (__DJGPP__) && !defined(__LIBPAYLOAD__)
  26 #include <unistd.h>
  27 #include <fcntl.h>
  28 #endif
  29 #if !defined (__DJGPP__)
  30 #include <errno.h>
  31 #endif
  32 #include "flash.h"
  33 #include "hwaccess.h"
  34
  35 #if defined(__i386__) || defined(__x86_64__)
  36
  37 /* sync primitive is not needed because x86 uses uncached accesses
  38  * which have a strongly ordered memory model.
  39  */
  40 static inline void sync_primitive(void)
  41 {
  42 }
  43
  44 #if defined(__FreeBSD__) || defined(__FreeBSD_kernel__) || defined(__DragonFly__)
  45 int io_fd;
  46 #endif
  47
  48 int release_io_perms(void *p)
  49 {
  50 #if defined(__DJGPP__) || defined(__LIBPAYLOAD__)
  51 #else
  52 #if defined (__sun) && (defined(__i386) || defined(__amd64))
  53         sysi86(SI86V86, V86SC_IOPL, 0);
  54 #elif defined(__FreeBSD__) || defined(__FreeBSD_kernel__) || defined (__DragonFly__)
  55         close(io_fd);
  56 #else
  57         iopl(0);
  58 #endif
  59 #endif
  60         return 0;
  61 }
  62
  63 /* Get I/O permissions with automatic permission release on shutdown. */
  64 int rget_io_perms(void)
  65 {
  66 #if defined(__DJGPP__) || defined(__LIBPAYLOAD__)
  67         /* We have full permissions by default. */
  68         return 0;
  69 #else
  70 #if defined (__sun) && (defined(__i386) || defined(__amd64))
  71         if (sysi86(SI86V86, V86SC_IOPL, PS_IOPL) != 0) {
  72 #elif defined(__FreeBSD__) || defined(__FreeBSD_kernel__) || defined (__DragonFly__)
  73         if ((io_fd = open("/dev/io", O_RDWR)) < 0) {
  74 #else
  75         if (iopl(3) != 0) {
  76 #endif
  77                 msg_perr("ERROR: Could not get I/O privileges (%s).\n"
  78                         "You need to be root.\n", strerror(errno));
  79 #if defined (__OpenBSD__)
  80                 msg_perr("Please set securelevel=-1 in /etc/rc.securelevel "
  81                            "and reboot, or reboot into \n");
  82                 msg_perr("single user mode.\n");
  83 #endif
  84                 return 1;
  85         } else {
  86                 register_shutdown(release_io_perms, NULL);
  87         }
  88         return 0;
  89 #endif
  90 }
  91
  92 #elif defined(__powerpc__) || defined(__powerpc64__) || defined(__ppc__) || defined(__ppc64__)
  93
  94 static inline void sync_primitive(void)
  95 {
  96         /* Prevent reordering and/or merging of reads/writes to hardware.
  97          * Such reordering and/or merging would break device accesses which
  98          * depend on the exact access order.
  99          */
 100         asm("eieio" : : : "memory");
 101 }
 102
 103 /* PCI port I/O is not yet implemented on PowerPC. */
 104 int rget_io_perms(void)
 105 {
 106         return 0;
 107 }
 108
 109 #elif defined (__mips) || defined (__mips__) || defined (_mips) || defined (mips)
 110
 111 /* sync primitive is not needed because /dev/mem on MIPS uses uncached accesses
 112  * in mode 2 which has a strongly ordered memory model.
 113  */
 114 static inline void sync_primitive(void)
 115 {
 116 }
 117
 118 /* PCI port I/O is not yet implemented on MIPS. */
 119 int rget_io_perms(void)
 120 {
 121         return 0;
 122 }
 123
 124 #elif defined (__arm__)
 125
 126 static inline void sync_primitive(void)
 127 {
 128 }
 129
 130 int rget_io_perms(void)
 131 {
 132         return 0;
 133 }
 134
 135 #else
 136
 137 #error Unknown architecture
 138
 139 #endif
 140
 141 void mmio_writeb(uint8_t val, void *addr)
 142 {
 143         *(volatile uint8_t *) addr = val;
 144         sync_primitive();
 145 }
 146
 147 void mmio_writew(uint16_t val, void *addr)
 148 {
 149         *(volatile uint16_t *) addr = val;
 150         sync_primitive();
 151 }
 152
 153 void mmio_writel(uint32_t val, void *addr)
 154 {
 155         *(volatile uint32_t *) addr = val;
 156         sync_primitive();
 157 }
 158
 159 uint8_t mmio_readb(void *addr)
 160 {
 161         return *(volatile uint8_t *) addr;
 162 }
 163
 164 uint16_t mmio_readw(void *addr)
 165 {
 166         return *(volatile uint16_t *) addr;
 167 }
 168
 169 uint32_t mmio_readl(void *addr)
 170 {
 171         return *(volatile uint32_t *) addr;
 172 }
 173
 174 void mmio_readn(void *addr, uint8_t *buf, size_t len)
 175 {
 176         memcpy(buf, addr, len);
 177         return;
 178 }
 179
 180 void mmio_le_writeb(uint8_t val, void *addr)
 181 {
 182         mmio_writeb(cpu_to_le8(val), addr);
 183 }
 184
 185 void mmio_le_writew(uint16_t val, void *addr)
 186 {
 187         mmio_writew(cpu_to_le16(val), addr);
 188 }
 189
 190 void mmio_le_writel(uint32_t val, void *addr)
 191 {
 192         mmio_writel(cpu_to_le32(val), addr);
 193 }
 194
 195 uint8_t mmio_le_readb(void *addr)
 196 {
 197         return le_to_cpu8(mmio_readb(addr));
 198 }
 199
 200 uint16_t mmio_le_readw(void *addr)
 201 {
 202         return le_to_cpu16(mmio_readw(addr));
 203 }
 204
 205 uint32_t mmio_le_readl(void *addr)
 206 {
 207         return le_to_cpu32(mmio_readl(addr));
 208 }
 209
 210 enum mmio_write_type {
 211         mmio_write_type_b,
 212         mmio_write_type_w,
 213         mmio_write_type_l,
 214 };
 215
 216 struct undo_mmio_write_data {
 217         void *addr;
 218         int reg;
 219         enum mmio_write_type type;
 220         union {
 221                 uint8_t bdata;
 222                 uint16_t wdata;
 223                 uint32_t ldata;
 224         };
 225 };
 226
 227 int undo_mmio_write(void *p)
 228 {
 229         struct undo_mmio_write_data *data = p;
 230         msg_pdbg("Restoring MMIO space at %p\n", data->addr);
 231         switch (data->type) {
 232         case mmio_write_type_b:
 233                 mmio_writeb(data->bdata, data->addr);
 234                 break;
 235         case mmio_write_type_w:
 236                 mmio_writew(data->wdata, data->addr);
 237                 break;
 238         case mmio_write_type_l:
 239                 mmio_writel(data->ldata, data->addr);
 240                 break;
 241         }
 242         /* p was allocated in register_undo_mmio_write. */
 243         free(p);
 244         return 0;
 245 }
 246
 247 #define register_undo_mmio_write(a, c)                                  \
 248 {                                                                       \
 249         struct undo_mmio_write_data *undo_mmio_write_data;              \
 250         undo_mmio_write_data = malloc(sizeof(struct undo_mmio_write_data)); \
 251         if (!undo_mmio_write_data) {                                    \
 252                 msg_gerr("Out of memory!\n");                           \
 253                 exit(1);                                                \
 254         }                                                               \
 255         undo_mmio_write_data->addr = a;                                 \
 256         undo_mmio_write_data->type = mmio_write_type_##c;               \
 257         undo_mmio_write_data->c##data = mmio_read##c(a);                \
 258         register_shutdown(undo_mmio_write, undo_mmio_write_data);       \
 259 }
 260
 261 #define register_undo_mmio_writeb(a) register_undo_mmio_write(a, b)
 262 #define register_undo_mmio_writew(a) register_undo_mmio_write(a, w)
 263 #define register_undo_mmio_writel(a) register_undo_mmio_write(a, l)
 264
 265 void rmmio_writeb(uint8_t val, void *addr)
 266 {
 267         register_undo_mmio_writeb(addr);
 268         mmio_writeb(val, addr);
 269 }
 270
 271 void rmmio_writew(uint16_t val, void *addr)
 272 {
 273         register_undo_mmio_writew(addr);
 274         mmio_writew(val, addr);
 275 }
 276
 277 void rmmio_writel(uint32_t val, void *addr)
 278 {
 279         register_undo_mmio_writel(addr);
 280         mmio_writel(val, addr);
 281 }
 282
 283 void rmmio_le_writeb(uint8_t val, void *addr)
 284 {
 285         register_undo_mmio_writeb(addr);
 286         mmio_le_writeb(val, addr);
 287 }
 288
 289 void rmmio_le_writew(uint16_t val, void *addr)
 290 {
 291         register_undo_mmio_writew(addr);
 292         mmio_le_writew(val, addr);
 293 }
 294
 295 void rmmio_le_writel(uint32_t val, void *addr)
 296 {
 297         register_undo_mmio_writel(addr);
 298         mmio_le_writel(val, addr);
 299 }
 300
 301 void rmmio_valb(void *addr)
 302 {
 303         register_undo_mmio_writeb(addr);
 304 }
 305
 306 void rmmio_valw(void *addr)
 307 {
 308         register_undo_mmio_writew(addr);
 309 }
 310
 311 void rmmio_vall(void *addr)
 312 {
 313         register_undo_mmio_writel(addr);
 314 }