]> mj.ucw.cz Git - pciutils.git/blob - lib/proc.c
Redhat and Mandrake fixes
[pciutils.git] / 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) & 0x7f;
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[1024];
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 };