2 * (C) Copyright IBM Corporation 2006
5 * Permission is hereby granted, free of charge, to any person obtaining a
6 * copy of this software and associated documentation files (the "Software"),
7 * to deal in the Software without restriction, including without limitation
8 * on the rights to use, copy, modify, merge, publish, distribute, sub
9 * license, and/or sell copies of the Software, and to permit persons to whom
10 * the Software is furnished to do so, subject to the following conditions:
12 * The above copyright notice and this permission notice (including the next
13 * paragraph) shall be included in all copies or substantial portions of the
16 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
17 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
18 * FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. IN NO EVENT SHALL
19 * IBM AND/OR THEIR SUPPLIERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
20 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
21 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
22 * DEALINGS IN THE SOFTWARE.
27 * Access PCI subsystem using Linux's sysfs interface. This interface is
28 * available starting somewhere in the late 2.5.x kernel phase, and is the
29 * preferred method on all 2.6.x kernels.
31 * \author Ian Romanick <idr@us.ibm.com>
40 #include <sys/types.h>
51 #include <sys/ioctl.h>
54 #include "pciaccess.h"
55 #include "pciaccess_private.h"
56 #include "linux_devmem.h"
58 static void pci_device_linux_sysfs_enable(struct pci_device *dev);
60 static int pci_device_linux_sysfs_read_rom( struct pci_device * dev,
63 static int pci_device_linux_sysfs_probe( struct pci_device * dev );
65 static int pci_device_linux_sysfs_map_range(struct pci_device *dev,
66 struct pci_device_mapping *map);
68 static int pci_device_linux_sysfs_unmap_range(struct pci_device *dev,
69 struct pci_device_mapping *map);
71 static int pci_device_linux_sysfs_read( struct pci_device * dev, void * data,
72 pciaddr_t offset, pciaddr_t size, pciaddr_t * bytes_read );
74 static int pci_device_linux_sysfs_write( struct pci_device * dev,
75 const void * data, pciaddr_t offset, pciaddr_t size,
76 pciaddr_t * bytes_written );
78 static int pci_device_linux_sysfs_boot_vga( struct pci_device * dev );
79 static int pci_device_linux_sysfs_has_kernel_driver(struct pci_device *dev);
81 static const struct pci_system_methods linux_sysfs_methods = {
83 .destroy_device = NULL,
84 .read_rom = pci_device_linux_sysfs_read_rom,
85 .probe = pci_device_linux_sysfs_probe,
86 .map_range = pci_device_linux_sysfs_map_range,
87 .unmap_range = pci_device_linux_sysfs_unmap_range,
89 .read = pci_device_linux_sysfs_read,
90 .write = pci_device_linux_sysfs_write,
92 .fill_capabilities = pci_fill_capabilities_generic,
93 .enable = pci_device_linux_sysfs_enable,
94 .boot_vga = pci_device_linux_sysfs_boot_vga,
95 .has_kernel_driver = pci_device_linux_sysfs_has_kernel_driver,
98 #define SYS_BUS_PCI "/sys/bus/pci/devices"
101 static int populate_entries(struct pci_system * pci_sys);
105 * Attempt to access PCI subsystem using Linux's sysfs interface.
108 pci_system_linux_sysfs_create( void )
114 /* If the directory "/sys/bus/pci/devices" exists, then the PCI subsystem
115 * can be accessed using this interface.
118 if ( stat( SYS_BUS_PCI, & st ) == 0 ) {
119 pci_sys = calloc( 1, sizeof( struct pci_system ) );
120 if ( pci_sys != NULL ) {
121 pci_sys->methods = & linux_sysfs_methods;
123 pci_sys->mtrr_fd = open("/proc/mtrr", O_WRONLY);
125 err = populate_entries(pci_sys);
140 * Filter out the names "." and ".." from the scanned sysfs entries.
142 * \param d Directory entry being processed by \c scandir.
145 * Zero if the entry name matches either "." or "..", non-zero otherwise.
147 * \sa scandir, populate_entries
150 scan_sys_pci_filter( const struct dirent * d )
152 return !((strcmp( d->d_name, "." ) == 0)
153 || (strcmp( d->d_name, ".." ) == 0));
158 populate_entries( struct pci_system * p )
160 struct dirent ** devices;
166 n = scandir( SYS_BUS_PCI, & devices, scan_sys_pci_filter, alphasort );
169 p->devices = calloc( n, sizeof( struct pci_device_private ) );
171 if (p->devices != NULL) {
172 for (i = 0 ; i < n ; i++) {
175 unsigned dom, bus, dev, func;
176 struct pci_device_private *device =
177 (struct pci_device_private *) &p->devices[i];
180 sscanf(devices[i]->d_name, "%04x:%02x:%02x.%1u",
181 & dom, & bus, & dev, & func);
183 device->base.domain = dom;
184 device->base.bus = bus;
185 device->base.dev = dev;
186 device->base.func = func;
189 err = pci_device_linux_sysfs_read(& device->base, config, 0,
191 if ((bytes == 48) && !err) {
192 device->base.vendor_id = (uint16_t)config[0]
193 + ((uint16_t)config[1] << 8);
194 device->base.device_id = (uint16_t)config[2]
195 + ((uint16_t)config[3] << 8);
196 device->base.device_class = (uint32_t)config[9]
197 + ((uint32_t)config[10] << 8)
198 + ((uint32_t)config[11] << 16);
199 device->base.revision = config[8];
200 device->base.subvendor_id = (uint16_t)config[44]
201 + ((uint16_t)config[45] << 8);
202 device->base.subdevice_id = (uint16_t)config[46]
203 + ((uint16_t)config[47] << 8);
216 for (i = 0; i < n; i++)
230 pci_device_linux_sysfs_probe( struct pci_device * dev )
241 err = pci_device_linux_sysfs_read( dev, config, 0, 256, & bytes );
243 struct pci_device_private *priv = (struct pci_device_private *) dev;
245 dev->irq = config[60];
246 priv->header_type = config[14];
249 /* The PCI config registers can be used to obtain information
250 * about the memory and I/O regions for the device. However,
251 * doing so requires some tricky parsing (to correctly handle
252 * 64-bit memory regions) and requires writing to the config
253 * registers. Since we'd like to avoid having to deal with the
254 * parsing issues and non-root users can write to PCI config
255 * registers, we use a different file in the device's sysfs
256 * directory called "resource".
258 * The resource file contains all of the needed information in
259 * a format that is consistent across all platforms. Each BAR
260 * and the expansion ROM have a single line of data containing
261 * 3, 64-bit hex values: the first address in the region,
262 * the last address in the region, and the region's flags.
264 snprintf( name, 255, "%s/%04x:%02x:%02x.%1u/resource",
270 fd = open( name, O_RDONLY );
278 bytes = read( fd, resource, 512 );
279 resource[511] = '\0';
284 for ( i = 0 ; i < 6 ; i++ ) {
286 dev->regions[i].base_addr = strtoull( next, & next, 16 );
287 high_addr = strtoull( next, & next, 16 );
288 flags = strtoull( next, & next, 16 );
290 if ( dev->regions[i].base_addr != 0 ) {
291 dev->regions[i].size = (high_addr
292 - dev->regions[i].base_addr) + 1;
294 dev->regions[i].is_IO = (flags & 0x01);
295 dev->regions[i].is_64 = (flags & 0x04);
296 dev->regions[i].is_prefetchable = (flags & 0x08);
300 low_addr = strtoull( next, & next, 16 );
301 high_addr = strtoull( next, & next, 16 );
302 flags = strtoull( next, & next, 16 );
303 if ( low_addr != 0 ) {
304 priv->rom_base = low_addr;
305 dev->rom_size = (high_addr - low_addr) + 1;
315 pci_device_linux_sysfs_read_rom( struct pci_device * dev, void * buffer )
325 snprintf( name, 255, "%s/%04x:%02x:%02x.%1u/rom",
332 fd = open( name, O_RDWR );
335 /* If reading the ROM using sysfs fails, fall back to the old
336 * /dev/mem based interface.
337 * disable this for newer kernels using configure
339 return pci_device_linux_devmem_read_rom(dev, buffer);
346 if ( fstat( fd, & st ) == -1 ) {
351 rom_size = st.st_size;
355 /* This is a quirky thing on Linux. Even though the ROM and the file
356 * for the ROM in sysfs are read-only, the string "1" must be written to
357 * the file to enable the ROM. After the data has been read, "0" must be
358 * written to the file to disable the ROM.
361 lseek( fd, 0, SEEK_SET );
363 for ( total_bytes = 0 ; total_bytes < rom_size ; /* empty */ ) {
364 const int bytes = read( fd, (char *) buffer + total_bytes,
365 rom_size - total_bytes );
370 else if ( bytes == 0 ) {
374 total_bytes += bytes;
378 lseek( fd, 0, SEEK_SET );
387 pci_device_linux_sysfs_read( struct pci_device * dev, void * data,
388 pciaddr_t offset, pciaddr_t size,
389 pciaddr_t * bytes_read )
392 pciaddr_t temp_size = size;
395 char *data_bytes = data;
397 if ( bytes_read != NULL ) {
401 /* Each device has a directory under sysfs. Within that directory there
402 * is a file named "config". This file used to access the PCI config
403 * space. It is used here to obtain most of the information about the
406 snprintf( name, 255, "%s/%04x:%02x:%02x.%1u/config",
413 fd = open( name, O_RDONLY );
419 while ( temp_size > 0 ) {
420 const ssize_t bytes = pread64( fd, data_bytes, temp_size, offset );
422 /* If zero bytes were read, then we assume it's the end of the
435 if ( bytes_read != NULL ) {
436 *bytes_read = size - temp_size;
445 pci_device_linux_sysfs_write( struct pci_device * dev, const void * data,
446 pciaddr_t offset, pciaddr_t size,
447 pciaddr_t * bytes_written )
450 pciaddr_t temp_size = size;
453 const char *data_bytes = data;
455 if ( bytes_written != NULL ) {
459 /* Each device has a directory under sysfs. Within that directory there
460 * is a file named "config". This file used to access the PCI config
461 * space. It is used here to obtain most of the information about the
464 snprintf( name, 255, "%s/%04x:%02x:%02x.%1u/config",
471 fd = open( name, O_WRONLY );
477 while ( temp_size > 0 ) {
478 const ssize_t bytes = pwrite64( fd, data_bytes, temp_size, offset );
480 /* If zero bytes were written, then we assume it's the end of the
493 if ( bytes_written != NULL ) {
494 *bytes_written = size - temp_size;
502 pci_device_linux_sysfs_map_range_wc(struct pci_device *dev,
503 struct pci_device_mapping *map)
507 const int prot = ((map->flags & PCI_DEV_MAP_FLAG_WRITABLE) != 0)
508 ? (PROT_READ | PROT_WRITE) : PROT_READ;
509 const int open_flags = ((map->flags & PCI_DEV_MAP_FLAG_WRITABLE) != 0)
511 const off_t offset = map->base - dev->regions[map->region].base_addr;
513 snprintf(name, 255, "%s/%04x:%02x:%02x.%1u/resource%u_wc",
520 fd = open(name, open_flags);
524 map->memory = mmap(NULL, map->size, prot, MAP_SHARED, fd, offset);
525 if (map->memory == MAP_FAILED) {
537 * Map a memory region for a device using the Linux sysfs interface.
539 * \param dev Device whose memory region is to be mapped.
540 * \param map Parameters of the mapping that is to be created.
543 * Zero on success or an \c errno value on failure.
545 * \sa pci_device_map_rrange, pci_device_linux_sysfs_unmap_range
548 * Some older 2.6.x kernels don't implement the resourceN files. On those
549 * systems /dev/mem must be used. On these systems it is also possible that
550 * \c mmap64 may need to be used.
553 pci_device_linux_sysfs_map_range(struct pci_device *dev,
554 struct pci_device_mapping *map)
559 const int prot = ((map->flags & PCI_DEV_MAP_FLAG_WRITABLE) != 0)
560 ? (PROT_READ | PROT_WRITE) : PROT_READ;
561 const int open_flags = ((map->flags & PCI_DEV_MAP_FLAG_WRITABLE) != 0)
563 const off_t offset = map->base - dev->regions[map->region].base_addr;
565 struct mtrr_sentry sentry = {
568 .type = MTRR_TYPE_UNCACHABLE
572 /* For WC mappings, try sysfs resourceN_wc file first */
573 if ((map->flags & PCI_DEV_MAP_FLAG_WRITE_COMBINE) &&
574 !pci_device_linux_sysfs_map_range_wc(dev, map))
577 snprintf(name, 255, "%s/%04x:%02x:%02x.%1u/resource%u",
585 fd = open(name, open_flags);
591 map->memory = mmap(NULL, map->size, prot, MAP_SHARED, fd, offset);
592 if (map->memory == MAP_FAILED) {
599 if ((map->flags & PCI_DEV_MAP_FLAG_CACHABLE) != 0) {
600 sentry.type = MTRR_TYPE_WRBACK;
601 } else if ((map->flags & PCI_DEV_MAP_FLAG_WRITE_COMBINE) != 0) {
602 sentry.type = MTRR_TYPE_WRCOMB;
605 if (pci_sys->mtrr_fd != -1 && sentry.type != MTRR_TYPE_UNCACHABLE) {
606 if (ioctl(pci_sys->mtrr_fd, MTRRIOC_ADD_ENTRY, &sentry) < 0) {
607 /* FIXME: Should we report an error in this case?
609 fprintf(stderr, "error setting MTRR "
610 "(base = 0x%08lx, size = 0x%08x, type = %u) %s (%d)\n",
611 sentry.base, sentry.size, sentry.type,
612 strerror(errno), errno);
615 /* KLUDGE ALERT -- rewrite the PTEs to turn off the CD and WT bits */
616 mprotect (map->memory, map->size, PROT_NONE);
617 err = mprotect (map->memory, map->size, PROT_READ|PROT_WRITE);
620 fprintf(stderr, "mprotect(PROT_READ | PROT_WRITE) failed: %s\n",
622 fprintf(stderr, "remapping without mprotect performance kludge.\n");
624 munmap(map->memory, map->size);
625 map->memory = mmap(NULL, map->size, prot, MAP_SHARED, fd, offset);
626 if (map->memory == MAP_FAILED) {
641 * Unmap a memory region for a device using the Linux sysfs interface.
643 * \param dev Device whose memory region is to be unmapped.
644 * \param map Parameters of the mapping that is to be destroyed.
647 * Zero on success or an \c errno value on failure.
649 * \sa pci_device_map_rrange, pci_device_linux_sysfs_map_range
652 * Some older 2.6.x kernels don't implement the resourceN files. On those
653 * systems /dev/mem must be used. On these systems it is also possible that
654 * \c mmap64 may need to be used.
657 pci_device_linux_sysfs_unmap_range(struct pci_device *dev,
658 struct pci_device_mapping *map)
662 struct mtrr_sentry sentry = {
665 .type = MTRR_TYPE_UNCACHABLE
669 err = pci_device_generic_unmap_range (dev, map);
674 if ((map->flags & PCI_DEV_MAP_FLAG_CACHABLE) != 0) {
675 sentry.type = MTRR_TYPE_WRBACK;
676 } else if ((map->flags & PCI_DEV_MAP_FLAG_WRITE_COMBINE) != 0) {
677 sentry.type = MTRR_TYPE_WRCOMB;
680 if (pci_sys->mtrr_fd != -1 && sentry.type != MTRR_TYPE_UNCACHABLE) {
681 if (ioctl(pci_sys->mtrr_fd, MTRRIOC_DEL_ENTRY, &sentry) < 0) {
682 /* FIXME: Should we report an error in this case?
684 fprintf(stderr, "error setting MTRR "
685 "(base = 0x%08lx, size = 0x%08x, type = %u) %s (%d)\n",
686 sentry.base, sentry.size, sentry.type,
687 strerror(errno), errno);
696 static void pci_device_linux_sysfs_enable(struct pci_device *dev)
701 snprintf( name, 255, "%s/%04x:%02x:%02x.%1u/enable",
708 fd = open( name, O_RDWR );
716 static int pci_device_linux_sysfs_boot_vga(struct pci_device *dev)
723 snprintf( name, 255, "%s/%04x:%02x:%02x.%1u/boot_vga",
730 fd = open( name, O_RDONLY );
734 bytes_read = read(fd, reply, 1);
744 static int pci_device_linux_sysfs_has_kernel_driver(struct pci_device *dev)
750 snprintf( name, 255, "%s/%04x:%02x:%02x.%1u/driver",
757 ret = stat(name, &dummy);