Annotation of embedaddon/pciutils/lib/sysfs.c, revision 1.1.1.1
1.1 misho 1: /*
2: * The PCI Library -- Configuration Access via /sys/bus/pci
3: *
4: * Copyright (c) 2003 Matthew Wilcox <matthew@wil.cx>
5: * Copyright (c) 1997--2008 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: pci_define_param(a, "sysfs.path", PCI_PATH_SYS_BUS_PCI, "Path to the sysfs device tree");
29: }
30:
31: static inline char *
32: sysfs_name(struct pci_access *a)
33: {
34: return pci_get_param(a, "sysfs.path");
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: a->fd_vpd = -1;
54: }
55:
56: static void
57: sysfs_flush_cache(struct pci_access *a)
58: {
59: if (a->fd >= 0)
60: {
61: close(a->fd);
62: a->fd = -1;
63: }
64: if (a->fd_vpd >= 0)
65: {
66: close(a->fd_vpd);
67: a->fd_vpd = -1;
68: }
69: a->cached_dev = NULL;
70: }
71:
72: static void
73: sysfs_cleanup(struct pci_access *a)
74: {
75: sysfs_flush_cache(a);
76: }
77:
78: #define OBJNAMELEN 1024
79: static void
80: sysfs_obj_name(struct pci_dev *d, char *object, char *buf)
81: {
82: int n = snprintf(buf, OBJNAMELEN, "%s/devices/%04x:%02x:%02x.%d/%s",
83: sysfs_name(d->access), d->domain, d->bus, d->dev, d->func, object);
84: if (n < 0 || n >= OBJNAMELEN)
85: d->access->error("File name too long");
86: }
87:
88: static int
89: sysfs_get_value(struct pci_dev *d, char *object)
90: {
91: struct pci_access *a = d->access;
92: int fd, n;
93: char namebuf[OBJNAMELEN], buf[256];
94:
95: sysfs_obj_name(d, object, namebuf);
96: fd = open(namebuf, O_RDONLY);
97: if (fd < 0)
98: a->error("Cannot open %s: %s", namebuf, strerror(errno));
99: n = read(fd, buf, sizeof(buf));
100: close(fd);
101: if (n < 0)
102: a->error("Error reading %s: %s", namebuf, strerror(errno));
103: if (n >= (int) sizeof(buf))
104: a->error("Value in %s too long", namebuf);
105: buf[n] = 0;
106: return strtol(buf, NULL, 0);
107: }
108:
109: static void
110: sysfs_get_resources(struct pci_dev *d)
111: {
112: struct pci_access *a = d->access;
113: char namebuf[OBJNAMELEN], buf[256];
114: FILE *file;
115: int i;
116:
117: sysfs_obj_name(d, "resource", namebuf);
118: file = fopen(namebuf, "r");
119: if (!file)
120: a->error("Cannot open %s: %s", namebuf, strerror(errno));
121: for (i = 0; i < 7; i++)
122: {
123: unsigned long long start, end, size, flags;
124: if (!fgets(buf, sizeof(buf), file))
125: break;
126: if (sscanf(buf, "%llx %llx %llx", &start, &end, &flags) != 3)
127: a->error("Syntax error in %s", namebuf);
128: if (start)
129: size = end - start + 1;
130: else
131: size = 0;
132: flags &= PCI_ADDR_FLAG_MASK;
133: if (i < 6)
134: {
135: d->base_addr[i] = start | flags;
136: d->size[i] = size;
137: }
138: else
139: {
140: d->rom_base_addr = start | flags;
141: d->rom_size = size;
142: }
143: }
144: fclose(file);
145: }
146:
147: static void sysfs_scan(struct pci_access *a)
148: {
149: char dirname[1024];
150: DIR *dir;
151: struct dirent *entry;
152: int n;
153:
154: n = snprintf(dirname, sizeof(dirname), "%s/devices", sysfs_name(a));
155: if (n < 0 || n >= (int) sizeof(dirname))
156: a->error("Directory name too long");
157: dir = opendir(dirname);
158: if (!dir)
159: a->error("Cannot open %s", dirname);
160: while ((entry = readdir(dir)))
161: {
162: struct pci_dev *d;
163: unsigned int dom, bus, dev, func;
164:
165: /* ".", ".." or a special non-device perhaps */
166: if (entry->d_name[0] == '.')
167: continue;
168:
169: d = pci_alloc_dev(a);
170: if (sscanf(entry->d_name, "%x:%x:%x.%d", &dom, &bus, &dev, &func) < 4)
171: a->error("sysfs_scan: Couldn't parse entry name %s", entry->d_name);
172: d->domain = dom;
173: d->bus = bus;
174: d->dev = dev;
175: d->func = func;
176: if (!a->buscentric)
177: {
178: sysfs_get_resources(d);
179: d->irq = sysfs_get_value(d, "irq");
180: /*
181: * We could read these faster from the config registers, but we want to give
182: * the kernel a chance to fix up ID's and especially classes of broken devices.
183: */
184: d->vendor_id = sysfs_get_value(d, "vendor");
185: d->device_id = sysfs_get_value(d, "device");
186: d->device_class = sysfs_get_value(d, "class") >> 8;
187: d->known_fields = PCI_FILL_IDENT | PCI_FILL_CLASS | PCI_FILL_IRQ | PCI_FILL_BASES | PCI_FILL_ROM_BASE | PCI_FILL_SIZES;
188: }
189: pci_link_dev(a, d);
190: }
191: closedir(dir);
192: }
193:
194: static void
195: sysfs_fill_slots(struct pci_access *a)
196: {
197: char dirname[1024];
198: DIR *dir;
199: struct dirent *entry;
200: int n;
201:
202: n = snprintf(dirname, sizeof(dirname), "%s/slots", sysfs_name(a));
203: if (n < 0 || n >= (int) sizeof(dirname))
204: a->error("Directory name too long");
205: dir = opendir(dirname);
206: if (!dir)
207: return;
208:
209: while (entry = readdir(dir))
210: {
211: char namebuf[OBJNAMELEN], buf[16];
212: FILE *file;
213: unsigned int dom, bus, dev;
214: struct pci_dev *d;
215:
216: /* ".", ".." or a special non-device perhaps */
217: if (entry->d_name[0] == '.')
218: continue;
219:
220: n = snprintf(namebuf, OBJNAMELEN, "%s/%s/%s", dirname, entry->d_name, "address");
221: if (n < 0 || n >= OBJNAMELEN)
222: a->error("File name too long");
223: file = fopen(namebuf, "r");
224: /*
225: * Old versions of Linux had a fakephp which didn't have an 'address'
226: * file. There's no useful information to be gleaned from these
227: * devices, pretend they're not there.
228: */
229: if (!file)
230: continue;
231:
232: if (!fgets(buf, sizeof(buf), file) || sscanf(buf, "%x:%x:%x", &dom, &bus, &dev) < 3)
233: a->warning("sysfs_fill_slots: Couldn't parse entry address %s", buf);
234: else
235: {
236: for (d = a->devices; d; d = d->next)
237: if (dom == d->domain && bus == d->bus && dev == d->dev && !d->phy_slot)
238: {
239: d->phy_slot = pci_malloc(a, strlen(entry->d_name) + 1);
240: strcpy(d->phy_slot, entry->d_name);
241: }
242: }
243: fclose(file);
244: }
245: closedir(dir);
246: }
247:
248: static int
249: sysfs_fill_info(struct pci_dev *d, int flags)
250: {
251: if ((flags & PCI_FILL_PHYS_SLOT) && !(d->known_fields & PCI_FILL_PHYS_SLOT))
252: {
253: struct pci_dev *pd;
254: sysfs_fill_slots(d->access);
255: for (pd = d->access->devices; pd; pd = pd->next)
256: pd->known_fields |= PCI_FILL_PHYS_SLOT;
257: }
258: return pci_generic_fill_info(d, flags);
259: }
260:
261: /* Intent of the sysfs_setup() caller */
262: enum
263: {
264: SETUP_READ_CONFIG = 0,
265: SETUP_WRITE_CONFIG = 1,
266: SETUP_READ_VPD = 2
267: };
268:
269: static int
270: sysfs_setup(struct pci_dev *d, int intent)
271: {
272: struct pci_access *a = d->access;
273: char namebuf[OBJNAMELEN];
274:
275: if (a->cached_dev != d || (intent == SETUP_WRITE_CONFIG && !a->fd_rw))
276: {
277: sysfs_flush_cache(a);
278: a->cached_dev = d;
279: }
280:
281: if (intent == SETUP_READ_VPD)
282: {
283: if (a->fd_vpd < 0)
284: {
285: sysfs_obj_name(d, "vpd", namebuf);
286: a->fd_vpd = open(namebuf, O_RDONLY);
287: /* No warning on error; vpd may be absent or accessible only to root */
288: }
289: return a->fd_vpd;
290: }
291:
292: if (a->fd < 0)
293: {
294: sysfs_obj_name(d, "config", namebuf);
295: a->fd_rw = a->writeable || intent == SETUP_WRITE_CONFIG;
296: a->fd = open(namebuf, a->fd_rw ? O_RDWR : O_RDONLY);
297: if (a->fd < 0)
298: a->warning("Cannot open %s", namebuf);
299: a->fd_pos = 0;
300: }
301: return a->fd;
302: }
303:
304: static int sysfs_read(struct pci_dev *d, int pos, byte *buf, int len)
305: {
306: int fd = sysfs_setup(d, SETUP_READ_CONFIG);
307: int res;
308:
309: if (fd < 0)
310: return 0;
311: res = do_read(d, fd, buf, len, pos);
312: if (res < 0)
313: {
314: d->access->warning("sysfs_read: read failed: %s", strerror(errno));
315: return 0;
316: }
317: else if (res != len)
318: return 0;
319: return 1;
320: }
321:
322: static int sysfs_write(struct pci_dev *d, int pos, byte *buf, int len)
323: {
324: int fd = sysfs_setup(d, SETUP_WRITE_CONFIG);
325: int res;
326:
327: if (fd < 0)
328: return 0;
329: res = do_write(d, fd, buf, len, pos);
330: if (res < 0)
331: {
332: d->access->warning("sysfs_write: write failed: %s", strerror(errno));
333: return 0;
334: }
335: else if (res != len)
336: {
337: d->access->warning("sysfs_write: tried to write %d bytes at %d, but only %d succeeded", len, pos, res);
338: return 0;
339: }
340: return 1;
341: }
342:
343: #ifdef PCI_HAVE_DO_READ
344:
345: /* pread() is not available and do_read() only works for a single fd, so we
346: * cannot implement read_vpd properly. */
347: static int sysfs_read_vpd(struct pci_dev *d, int pos, byte *buf, int len)
348: {
349: return 0;
350: }
351:
352: #else /* !PCI_HAVE_DO_READ */
353:
354: static int sysfs_read_vpd(struct pci_dev *d, int pos, byte *buf, int len)
355: {
356: int fd = sysfs_setup(d, SETUP_READ_VPD);
357: int res;
358:
359: if (fd < 0)
360: return 0;
361: res = pread(fd, buf, len, pos);
362: if (res < 0)
363: {
364: d->access->warning("sysfs_read_vpd: read failed: %s", strerror(errno));
365: return 0;
366: }
367: else if (res != len)
368: return 0;
369: return 1;
370: }
371:
372: #endif /* PCI_HAVE_DO_READ */
373:
374: static void sysfs_cleanup_dev(struct pci_dev *d)
375: {
376: struct pci_access *a = d->access;
377:
378: if (a->cached_dev == d)
379: sysfs_flush_cache(a);
380: }
381:
382: struct pci_methods pm_linux_sysfs = {
383: "linux-sysfs",
384: "The sys filesystem on Linux",
385: sysfs_config,
386: sysfs_detect,
387: sysfs_init,
388: sysfs_cleanup,
389: sysfs_scan,
390: sysfs_fill_info,
391: sysfs_read,
392: sysfs_write,
393: sysfs_read_vpd,
394: NULL, /* init_dev */
395: sysfs_cleanup_dev
396: };
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to sysfs.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / pciutils / lib