lib/proc.c

   1 /*
   2  *      The PCI Library -- Configuration Access via /proc/bus/pci
   3  *
   4  *      Copyright (c) 1997--2003 Martin Mares <mj@ucw.cz>
   5  *
   6  *      Can be freely distributed and used under the terms of the GNU GPL.
   7  */
   8
   9 #define _GNU_SOURCE
  10
  11 #include <stdio.h>
  12 #include <string.h>
  13 #include <unistd.h>
  14 #include <errno.h>
  15 #include <fcntl.h>
  16 #include <sys/types.h>
  17
  18 #include "internal.h"
  19
  20 /*
  21  *  We'd like to use pread/pwrite for configuration space accesses, but
  22  *  unfortunately it isn't simple at all since all libc's until glibc 2.1
  23  *  don't define it.
  24  */
  25
  26 #if defined(__GLIBC__) && __GLIBC__ == 2 && __GLIBC_MINOR__ > 0
  27 /* glibc 2.1 or newer -> pread/pwrite supported automatically */
  28
  29 #elif defined(i386) && defined(__GLIBC__)
  30 /* glibc 2.0 on i386 -> call syscalls directly */
  31 #include <asm/unistd.h>
  32 #include <syscall-list.h>
  33 #ifndef SYS_pread
  34 #define SYS_pread 180
  35 #endif
  36 static int pread(unsigned int fd, void *buf, size_t size, loff_t where)
  37 { return syscall(SYS_pread, fd, buf, size, where); }
  38 #ifndef SYS_pwrite
  39 #define SYS_pwrite 181
  40 #endif
  41 static int pwrite(unsigned int fd, void *buf, size_t size, loff_t where)
  42 { return syscall(SYS_pwrite, fd, buf, size, where); }
  43
  44 #elif defined(i386)
  45 /* old libc on i386 -> call syscalls directly the old way */
  46 #include <asm/unistd.h>
  47 static _syscall5(int, pread, unsigned int, fd, void *, buf, size_t, size, u32, where_lo, u32, where_hi);
  48 static _syscall5(int, pwrite, unsigned int, fd, void *, buf, size_t, size, u32, where_lo, u32, where_hi);
  49 static int do_read(struct pci_dev *d UNUSED, int fd, void *buf, size_t size, int where) { return pread(fd, buf, size, where, 0); }
  50 static int do_write(struct pci_dev *d UNUSED, int fd, void *buf, size_t size, int where) { return pwrite(fd, buf, size, where, 0); }
  51 #define HAVE_DO_READ
  52
  53 #else
  54 /* In all other cases we use lseek/read/write instead to be safe */
  55 #define make_rw_glue(op) \
  56         static int do_##op(struct pci_dev *d, int fd, void *buf, size_t size, int where)        \
  57         {                                                                                       \
  58           struct pci_access *a = d->access;                                                     \
  59           int r;                                                                                \
  60           if (a->fd_pos != where && lseek(fd, where, SEEK_SET) < 0)                             \
  61             return -1;                                                                          \
  62           r = op(fd, buf, size);                                                                \
  63           if (r < 0)                                                                            \
  64             a->fd_pos = -1;                                                                     \
  65           else                                                                                  \
  66             a->fd_pos = where + r;                                                              \
  67           return r;                                                                             \
  68         }
  69 make_rw_glue(read)
  70 make_rw_glue(write)
  71 #define HAVE_DO_READ
  72 #endif
  73
  74 #ifndef HAVE_DO_READ
  75 #define do_read(d,f,b,l,p) pread(f,b,l,p)
  76 #define do_write(d,f,b,l,p) pwrite(f,b,l,p)
  77 #endif
  78
  79 static void
  80 proc_config(struct pci_access *a)
  81 {
  82   a->method_params[PCI_ACCESS_PROC_BUS_PCI] = PATH_PROC_BUS_PCI;
  83 }
  84
  85 static int
  86 proc_detect(struct pci_access *a)
  87 {
  88   char *name = a->method_params[PCI_ACCESS_PROC_BUS_PCI];
  89
  90   if (access(name, R_OK))
  91     {
  92       a->warning("Cannot open %s", name);
  93       return 0;
  94     }
  95   a->debug("...using %s", name);
  96   return 1;
  97 }
  98
  99 static void
 100 proc_init(struct pci_access *a)
 101 {
 102   a->fd = -1;
 103 }
 104
 105 static void
 106 proc_cleanup(struct pci_access *a)
 107 {
 108   if (a->fd >= 0)
 109     {
 110       close(a->fd);
 111       a->fd = -1;
 112     }
 113 }
 114
 115 static void
 116 proc_scan(struct pci_access *a)
 117 {
 118   FILE *f;
 119   char buf[512];
 120
 121   if (snprintf(buf, sizeof(buf), "%s/devices", a->method_params[PCI_ACCESS_PROC_BUS_PCI]) == sizeof(buf))
 122     a->error("File name too long");
 123   f = fopen(buf, "r");
 124   if (!f)
 125     a->error("Cannot open %s", buf);
 126   while (fgets(buf, sizeof(buf)-1, f))
 127     {
 128       struct pci_dev *d = pci_alloc_dev(a);
 129       unsigned int dfn, vend, cnt, known;
 130
 131 #define F " " PCIADDR_T_FMT
 132       cnt = sscanf(buf, "%x %x %x" F F F F F F F F F F F F F F,
 133              &dfn,
 134              &vend,
 135              &d->irq,
 136              &d->base_addr[0],
 137              &d->base_addr[1],
 138              &d->base_addr[2],
 139              &d->base_addr[3],
 140              &d->base_addr[4],
 141              &d->base_addr[5],
 142              &d->rom_base_addr,
 143              &d->size[0],
 144              &d->size[1],
 145              &d->size[2],
 146              &d->size[3],
 147              &d->size[4],
 148              &d->size[5],
 149              &d->rom_size);
 150 #undef F
 151       if (cnt != 9 && cnt != 10 && cnt != 17)
 152         a->error("proc: parse error (read only %d items)", cnt);
 153       d->bus = dfn >> 8U;
 154       d->dev = PCI_SLOT(dfn & 0xff);
 155       d->func = PCI_FUNC(dfn & 0xff);
 156       d->vendor_id = vend >> 16U;
 157       d->device_id = vend & 0xffff;
 158       d->hdrtype = pci_read_byte(d, PCI_HEADER_TYPE);
 159       known = PCI_FILL_IDENT;
 160       if (!a->buscentric)
 161         {
 162           known |= PCI_FILL_IRQ | PCI_FILL_BASES;
 163           if (cnt >= 10)
 164             known |= PCI_FILL_ROM_BASE;
 165           if (cnt >= 17)
 166             known |= PCI_FILL_SIZES;
 167         }
 168       d->known_fields = known;
 169       pci_link_dev(a, d);
 170     }
 171   fclose(f);
 172 }
 173
 174 static int
 175 proc_setup(struct pci_dev *d, int rw)
 176 {
 177   struct pci_access *a = d->access;
 178
 179   if (a->cached_dev != d || a->fd_rw < rw)
 180     {
 181       char buf[256];
 182       if (a->fd >= 0)
 183         close(a->fd);
 184       if (snprintf(buf, sizeof(buf), "%s/%02x/%02x.%d", a->method_params[PCI_ACCESS_PROC_BUS_PCI],
 185                    d->bus, d->dev, d->func) == sizeof(buf))
 186         a->error("File name too long");
 187       a->fd_rw = a->writeable || rw;
 188       a->fd = open(buf, a->fd_rw ? O_RDWR : O_RDONLY);
 189       if (a->fd < 0)
 190         a->warning("Cannot open %s", buf);
 191       a->cached_dev = d;
 192       a->fd_pos = 0;
 193     }
 194   return a->fd;
 195 }
 196
 197 static int
 198 proc_read(struct pci_dev *d, int pos, byte *buf, int len)
 199 {
 200   int fd = proc_setup(d, 0);
 201   int res;
 202
 203   if (fd < 0)
 204     return 0;
 205   res = do_read(d, fd, buf, len, pos);
 206   if (res < 0)
 207     {
 208       d->access->warning("proc_read: read failed: %s", strerror(errno));
 209       return 0;
 210     }
 211   else if (res != len)
 212     {
 213       d->access->warning("proc_read: tried to read %d bytes at %d, but got only %d", len, pos, res);
 214       return 0;
 215     }
 216   return 1;
 217 }
 218
 219 static int
 220 proc_write(struct pci_dev *d, int pos, byte *buf, int len)
 221 {
 222   int fd = proc_setup(d, 1);
 223   int res;
 224
 225   if (fd < 0)
 226     return 0;
 227   res = do_write(d, fd, buf, len, pos);
 228   if (res < 0)
 229     {
 230       d->access->warning("proc_write: write failed: %s", strerror(errno));
 231       return 0;
 232     }
 233   else if (res != len)
 234     {
 235       d->access->warning("proc_write: tried to write %d bytes at %d, but got only %d", len, pos, res);
 236       return 0;
 237     }
 238   return 1;
 239 }
 240
 241 static void
 242 proc_cleanup_dev(struct pci_dev *d)
 243 {
 244   if (d->access->cached_dev == d)
 245     d->access->cached_dev = NULL;
 246 }
 247
 248 struct pci_methods pm_linux_proc = {
 249   "/proc/bus/pci",
 250   proc_config,
 251   proc_detect,
 252   proc_init,
 253   proc_cleanup,
 254   proc_scan,
 255   pci_generic_fill_info,
 256   proc_read,
 257   proc_write,
 258   NULL,                                 /* init_dev */
 259   proc_cleanup_dev
 260 };