]> mj.ucw.cz Git - pciutils.git/blob - lib/sysfs.c
Fixed 64 bit addresses and released as 2.2.0.
[pciutils.git] / lib / sysfs.c
1 /*
2  *      The PCI Library -- Configuration Access via /sys/bus/pci
3  *
4  *      Copyright (c) 2003 Matthew Wilcox <willy@fc.hp.com>
5  *      Copyright (c) 1997--2003 Martin Mares <mj@ucw.cz>
6  *
7  *      Can be freely distributed and used under the terms of the GNU GPL.
8  */
9
10 #define _GNU_SOURCE
11
12 #include <stdio.h>
13 #include <stdlib.h>
14 #include <string.h>
15 #include <stdarg.h>
16 #include <unistd.h>
17 #include <errno.h>
18 #include <dirent.h>
19 #include <fcntl.h>
20 #include <sys/types.h>
21
22 #include "internal.h"
23 #include "pread.h"
24
25 static void
26 sysfs_config(struct pci_access *a)
27 {
28   a->method_params[PCI_ACCESS_SYS_BUS_PCI] = PCI_PATH_SYS_BUS_PCI;
29 }
30
31 static inline char *
32 sysfs_name(struct pci_access *a)
33 {
34   return a->method_params[PCI_ACCESS_SYS_BUS_PCI];
35 }
36
37 static int
38 sysfs_detect(struct pci_access *a)
39 {
40   if (access(sysfs_name(a), R_OK))
41     {
42       a->debug("...cannot open %s", sysfs_name(a));
43       return 0;
44     }
45   a->debug("...using %s", sysfs_name(a));
46   return 1;
47 }
48
49 static void
50 sysfs_init(struct pci_access *a)
51 {
52   a->fd = -1;
53 }
54
55 static void
56 sysfs_cleanup(struct pci_access *a)
57 {
58   if (a->fd >= 0)
59     {
60       close(a->fd);
61       a->fd = -1;
62     }
63 }
64
65 #define OBJNAMELEN 1024
66 static void
67 sysfs_obj_name(struct pci_dev *d, char *object, char *buf)
68 {
69   int n = snprintf(buf, OBJNAMELEN, "%s/devices/%04x:%02x:%02x.%d/%s",
70                    sysfs_name(d->access), d->domain, d->bus, d->dev, d->func, object);
71   if (n < 0 || n >= OBJNAMELEN)
72     d->access->error("File name too long");
73 }
74
75 static int
76 sysfs_get_value(struct pci_dev *d, char *object)
77 {
78   struct pci_access *a = d->access;
79   int fd, n;
80   char namebuf[OBJNAMELEN], buf[256];
81
82   sysfs_obj_name(d, object, namebuf);
83   fd = open(namebuf, O_RDONLY);
84   if (fd < 0)
85     a->error("Cannot open %s: %s", namebuf, strerror(errno));
86   n = read(fd, buf, sizeof(buf));
87   close(fd);
88   if (n < 0)
89     a->error("Error reading %s: %s", namebuf, strerror(errno));
90   if (n >= (int) sizeof(buf))
91     a->error("Value in %s too long", namebuf);
92   buf[n] = 0;
93   return strtol(buf, NULL, 0);
94 }
95
96 static void
97 sysfs_get_resources(struct pci_dev *d)
98 {
99   struct pci_access *a = d->access;
100   char namebuf[OBJNAMELEN], buf[256];
101   FILE *file;
102   int i;
103
104   sysfs_obj_name(d, "resource", namebuf);
105   file = fopen(namebuf, "r");
106   if (!file)
107     a->error("Cannot open %s: %s", namebuf, strerror(errno));
108   for (i = 0; i < 7; i++)
109     {
110       unsigned long long start, end, size;
111       if (!fgets(buf, sizeof(buf), file))
112         break;
113       if (sscanf(buf, "%llx %llx", &start, &end) != 2)
114         a->error("Syntax error in %s", namebuf);
115       if (start)
116         size = end - start + 1;
117       else
118         size = 0;
119       if (i < 6)
120         {
121           d->base_addr[i] = start;
122           d->size[i] = size;
123         }
124       else
125         {
126           d->rom_base_addr = start;
127           d->rom_size = size;
128         }
129     }
130   fclose(file);
131 }
132
133 static void sysfs_scan(struct pci_access *a)
134 {
135   char dirname[1024];
136   DIR *dir;
137   struct dirent *entry;
138   int n;
139
140   n = snprintf(dirname, sizeof(dirname), "%s/devices", sysfs_name(a));
141   if (n < 0 || n >= (int) sizeof(dirname))
142     a->error("Directory name too long");
143   dir = opendir(dirname);
144   if (!dir)
145     a->error("Cannot open %s", dirname);
146   while ((entry = readdir(dir)))
147     {
148       struct pci_dev *d;
149       unsigned int dom, bus, dev, func;
150
151       /* ".", ".." or a special non-device perhaps */
152       if (entry->d_name[0] == '.')
153         continue;
154
155       d = pci_alloc_dev(a);
156       if (sscanf(entry->d_name, "%x:%x:%x.%d", &dom, &bus, &dev, &func) < 4)
157         a->error("sysfs_scan: Couldn't parse entry name %s", entry->d_name);
158       d->domain = dom;
159       d->bus = bus;
160       d->dev = dev;
161       d->func = func;
162       if (!a->buscentric)
163         {
164           sysfs_get_resources(d);
165           d->irq = sysfs_get_value(d, "irq");
166           d->known_fields = PCI_FILL_IRQ | PCI_FILL_BASES | PCI_FILL_ROM_BASE | PCI_FILL_SIZES;
167 #if 0
168           /*
169            *  We prefer reading these from the config registers, it's faster.
170            *  However, it would be possible and maybe even useful to hack the kernel
171            *  to believe that some device has a different ID. If you do it, just
172            *  enable this piece of code.  --mj
173            */
174           d->vendor_id = sysfs_get_value(d, "vendor");
175           d->device_id = sysfs_get_value(d, "device");
176           d->known_fields |= PCI_FILL_IDENT;
177 #endif
178         }
179       pci_link_dev(a, d);
180     }
181   closedir(dir);
182 }
183
184 static int
185 sysfs_setup(struct pci_dev *d, int rw)
186 {
187   struct pci_access *a = d->access;
188
189   if (a->cached_dev != d || a->fd_rw < rw)
190     {
191       char namebuf[OBJNAMELEN];
192       if (a->fd >= 0)
193         close(a->fd);
194       sysfs_obj_name(d, "config", namebuf);
195       a->fd_rw = a->writeable || rw;
196       a->fd = open(namebuf, a->fd_rw ? O_RDWR : O_RDONLY);
197       if (a->fd < 0)
198         a->warning("Cannot open %s", namebuf);
199       a->cached_dev = d;
200       a->fd_pos = 0;
201     }
202   return a->fd;
203 }
204
205 static int sysfs_read(struct pci_dev *d, int pos, byte *buf, int len)
206 {
207   int fd = sysfs_setup(d, 0);
208   int res;
209
210   if (fd < 0)
211     return 0;
212   res = do_read(d, fd, buf, len, pos);
213   if (res < 0)
214     {
215       d->access->warning("sysfs_read: read failed: %s", strerror(errno));
216       return 0;
217     }
218   else if (res != len)
219     return 0;
220   return 1;
221 }
222
223 static int sysfs_write(struct pci_dev *d, int pos, byte *buf, int len)
224 {
225   int fd = sysfs_setup(d, 1);
226   int res;
227
228   if (fd < 0)
229     return 0;
230   res = do_write(d, fd, buf, len, pos);
231   if (res < 0)
232     {
233       d->access->warning("sysfs_write: write failed: %s", strerror(errno));
234       return 0;
235     }
236   else if (res != len)
237     {
238       d->access->warning("sysfs_write: tried to write %d bytes at %d, but only %d succeeded", len, pos, res);
239       return 0;
240     }
241   return 1;
242 }
243
244 static void sysfs_cleanup_dev(struct pci_dev *d)
245 {
246   struct pci_access *a = d->access;
247
248   if (a->cached_dev == d)
249     {
250       a->cached_dev = NULL;
251       close(a->fd);
252       a->fd = -1;
253     }
254 }
255
256 struct pci_methods pm_linux_sysfs = {
257   "Linux-sysfs",
258   sysfs_config,
259   sysfs_detect,
260   sysfs_init,
261   sysfs_cleanup,
262   sysfs_scan,
263   pci_generic_fill_info,
264   sysfs_read,
265   sysfs_write,
266   NULL,                                 /* init_dev */
267   sysfs_cleanup_dev
268 };