sysdeps/unix/sysv/linux/ia64/ioperm.c

   1 /* Copyright (C) 1999, 2000, 2001, 2004 Free Software Foundation, Inc.
   2    This file is part of the GNU C Library.
   3    Contributed by David Mosberger-Tang <davidm@hpl.hp.com>.
   4
   5    The GNU C Library is free software; you can redistribute it and/or
   6    modify it under the terms of the GNU Lesser General Public
   7    License as published by the Free Software Foundation; either
   8    version 2.1 of the License, or (at your option) any later version.
   9
  10    The GNU C Library is distributed in the hope that it will be useful,
  11    but WITHOUT ANY WARRANTY; without even the implied warranty of
  12    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13    Lesser General Public License for more details.
  14
  15    You should have received a copy of the GNU Lesser General Public
  16    License along with the GNU C Library; if not, see
  17    <http://www.gnu.org/licenses/>.  */
  18
  19 /* I/O access is restricted to ISA port space (ports 0..65535).
  20    Modern devices hopefully are sane enough not to put any performance
  21    critical registers in i/o space.
  22
  23    On the first call to ioperm() or iopl(), the entire (E)ISA port
  24    space is mapped into the virtual address space at address io.base.
  25    mprotect() calls are then used to enable/disable access to ports.
  26    Per 4KB page, there are 4 I/O ports.  */
  27
  28 #include <errno.h>
  29 #include <fcntl.h>
  30 #include <ctype.h>
  31 #include <stdlib.h>
  32 #include <string.h>
  33 #include <unistd.h>
  34
  35 #include <sys/types.h>
  36 #include <sys/mman.h>
  37
  38 #define MAX_PORT        0x10000
  39
  40 /*
  41  * Memory fence w/accept.  This should never be used in code that is
  42  * not IA-64 specific.
  43  */
  44 #define __ia64_mf_a()   __asm__ __volatile__ ("mf.a" ::: "memory")
  45
  46 static struct
  47   {
  48     unsigned long int base;
  49     unsigned long int page_mask;
  50   }
  51 io;
  52
  53 __inline__ unsigned long int
  54 io_offset (unsigned long int port)
  55 {
  56         return ((port >> 2) << 12) | (port & 0xfff);
  57 }
  58
  59 int
  60 _ioperm (unsigned long int from, unsigned long int num, int turn_on)
  61 {
  62 #if 0
  63   unsigned long int addr, len, base;
  64 #endif
  65   unsigned long int base;
  66   int prot;
  67
  68   /* this test isn't as silly as it may look like; consider overflows! */
  69   if (from >= MAX_PORT || from + num > MAX_PORT)
  70     {
  71       __set_errno (EINVAL);
  72       return -1;
  73     }
  74
  75   if (turn_on)
  76     {
  77       if (!io.base)
  78         {
  79           unsigned long phys_io_base, len;
  80           int fd;
  81
  82           io.page_mask = ~(__getpagesize() - 1);
  83
  84           /* get I/O base physical address from ar.k0 as per PRM: */
  85           __asm__ ("mov %0=ar.k0" : "=r"(phys_io_base));
  86
  87           /* The O_SYNC flag tells the /dev/mem driver to map the
  88              memory uncached: */
  89           fd = __open ("/dev/mem", O_RDWR | O_SYNC);
  90           if (fd < 0)
  91             return -1;
  92
  93           len = io_offset (MAX_PORT);
  94 #if 1
  95           /* see comment below */
  96           base = (unsigned long int) __mmap (0, len, PROT_READ | PROT_WRITE, MAP_SHARED,
  97                                                 fd, phys_io_base);
  98 #else
  99           base = (unsigned long int) __mmap (0, len, PROT_NONE, MAP_SHARED,
 100                                                 fd, phys_io_base);
 101 #endif
 102           __close (fd);
 103
 104           if ((long) base == -1)
 105             return -1;
 106
 107           io.base = base;
 108         }
 109       prot = PROT_READ | PROT_WRITE;
 110     }
 111   else
 112     {
 113       if (!io.base)
 114         return 0;       /* never was turned on... */
 115
 116       prot = PROT_NONE;
 117     }
 118 #if 0
 119   /* We can't do mprotect because that would cause us to lose the
 120      uncached flag that the /dev/mem driver turned on.  A MAP_UNCACHED
 121      flag seems so much cleaner...  */
 122   addr = (io.base + io_offset (from)) & io.page_mask;
 123   len  = io.base + io_offset (from + num) - addr;
 124   return mprotect ((void *) addr, len, prot);
 125 #else
 126   return 0;
 127 #endif
 128 }
 129
 130 int
 131 _iopl (unsigned int level)
 132 {
 133   if (level > 3)
 134     {
 135       __set_errno (EINVAL);
 136       return -1;
 137     }
 138   if (level)
 139     {
 140       int retval = _ioperm (0, MAX_PORT, 1);
 141       /* Match the documented error returns of the x86 version.  */
 142       if (retval < 0 && errno == EACCES)
 143         __set_errno (EPERM);
 144       return retval;
 145     }
 146   return 0;
 147 }
 148
 149 unsigned int
 150 _inb (unsigned long int port)
 151 {
 152   volatile unsigned char *addr = (void *) io.base + io_offset (port);
 153   unsigned char ret;
 154
 155   ret = *addr;
 156   __ia64_mf_a();
 157   return ret;
 158 }
 159
 160 unsigned int
 161 _inw (unsigned long int port)
 162 {
 163   volatile unsigned short *addr = (void *) io.base + io_offset (port);
 164   unsigned short ret;
 165
 166   ret = *addr;
 167   __ia64_mf_a();
 168   return ret;
 169 }
 170
 171 unsigned int
 172 _inl (unsigned long int port)
 173 {
 174   volatile unsigned int *addr = (void *) io.base + io_offset (port);
 175   unsigned int ret;
 176
 177   ret = *addr;
 178   __ia64_mf_a();
 179   return ret;
 180 }
 181
 182 void
 183 _outb (unsigned char val, unsigned long int port)
 184 {
 185   volatile unsigned char *addr = (void *) io.base + io_offset (port);
 186
 187   *addr = val;
 188   __ia64_mf_a();
 189 }
 190
 191 void
 192 _outw (unsigned short val, unsigned long int port)
 193 {
 194   volatile unsigned short *addr = (void *) io.base + io_offset (port);
 195
 196   *addr = val;
 197   __ia64_mf_a();
 198 }
 199
 200 void
 201 _outl (unsigned int val, unsigned long int port)
 202 {
 203   volatile unsigned int *addr = (void *) io.base + io_offset (port);
 204
 205   *addr = val;
 206   __ia64_mf_a();
 207 }
 208
 209 weak_alias (_ioperm, ioperm);
 210 weak_alias (_iopl, iopl);
 211 weak_alias (_inb, inb);
 212 weak_alias (_inw, inw);
 213 weak_alias (_inl, inl);
 214 weak_alias (_outb, outb);
 215 weak_alias (_outw, outw);
 216 weak_alias (_outl, outl);