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 * prefered method on all 2.6.x kernels.
31 * \author Ian Romanick <idr@us.ibm.com>
40 #include <sys/types.h>
47 #include "pciaccess.h"
48 #include "pciaccess_private.h"
50 static int pci_device_linux_sysfs_read_rom( struct pci_device * dev,
53 static int pci_device_linux_sysfs_probe( struct pci_device * dev );
55 static int pci_device_linux_sysfs_map_region( struct pci_device * dev,
56 unsigned region, int write_enable );
58 static int pci_device_linux_sysfs_unmap_region( struct pci_device * dev,
61 static int pci_device_linux_sysfs_read( struct pci_device * dev, void * data,
62 pciaddr_t offset, pciaddr_t size, pciaddr_t * bytes_read );
64 static int pci_device_linux_sysfs_write( struct pci_device * dev,
65 const void * data, pciaddr_t offset, pciaddr_t size,
66 pciaddr_t * bytes_wrtten );
68 static const struct pci_system_methods linux_sysfs_methods = {
70 .destroy_device = NULL,
71 .read_rom = pci_device_linux_sysfs_read_rom,
72 .probe = pci_device_linux_sysfs_probe,
73 .map = pci_device_linux_sysfs_map_region,
74 .unmap = pci_device_linux_sysfs_unmap_region,
76 .read = pci_device_linux_sysfs_read,
77 .write = pci_device_linux_sysfs_write,
79 .fill_capabilities = pci_fill_capabilities_generic
82 #define SYS_BUS_PCI "/sys/bus/pci/devices"
85 static void populate_entries( struct pci_system * pci_sys );
89 * Attempt to access PCI subsystem using Linux's sysfs interface.
92 pci_system_linux_sysfs_create( void )
98 /* If the directory "/sys/bus/pci/devices" exists, then the PCI subsystem
99 * can be accessed using this interface.
102 if ( stat( SYS_BUS_PCI, & st ) == 0 ) {
103 pci_sys = calloc( 1, sizeof( struct pci_system ) );
104 if ( pci_sys != NULL ) {
105 pci_sys->methods = & linux_sysfs_methods;
106 populate_entries( pci_sys );
121 * Filter out the names "." and ".." from the scanned sysfs entries.
123 * \param d Directory entry being processed by \c scandir.
126 * Zero if the entry name matches either "." or "..", non-zero otherwise.
128 * \sa scandir, populate_entries
131 scan_sys_pci_filter( const struct dirent * d )
133 return !((strcmp( d->d_name, "." ) == 0)
134 || (strcmp( d->d_name, ".." ) == 0));
139 populate_entries( struct pci_system * p )
141 struct dirent ** devices;
146 n = scandir( SYS_BUS_PCI, & devices, scan_sys_pci_filter, alphasort );
149 p->devices = calloc( n, sizeof( struct pci_device_private ) );
152 for ( i = 0 ; i < n ; i++ ) {
153 unsigned dom, bus, dev, func;
156 sscanf( devices[ i ]->d_name, "%04x:%02x:%02x.%1u",
157 & dom, & bus, & dev, & func );
159 p->devices[ i ].base.domain = dom;
160 p->devices[ i ].base.bus = bus;
161 p->devices[ i ].base.dev = dev;
162 p->devices[ i ].base.func = func;
169 pci_device_linux_sysfs_probe( struct pci_device * dev )
180 err = pci_device_linux_sysfs_read( dev, config, 0, 256, & bytes );
182 struct pci_device_private *priv = (struct pci_device_private *) dev;
184 dev->vendor_id = (uint16_t)config[0] + ((uint16_t)config[1] << 8);
185 dev->device_id = (uint16_t)config[2] + ((uint16_t)config[3] << 8);
186 dev->device_class = (uint32_t)config[9] + ((uint32_t)config[10] << 8)
187 + ((uint32_t)config[11] << 16);
188 dev->revision = config[8];
189 dev->subvendor_id = (uint16_t)config[44] + ((uint16_t)config[45] << 8);
190 dev->subdevice_id = (uint16_t)config[46] + ((uint16_t)config[47] << 8);
191 dev->irq = config[60];
193 priv->header_type = config[14];
196 /* The PCI config registers can be used to obtain information
197 * about the memory and I/O regions for the device. However,
198 * doing so requires some tricky parsing (to correctly handle
199 * 64-bit memory regions) and requires writing to the config
200 * registers. Since we'd like to avoid having to deal with the
201 * parsing issues and non-root users can write to PCI config
202 * registers, we use a different file in the device's sysfs
203 * directory called "resource".
205 * The resource file contains all of the needed information in
206 * a format that is consistent across all platforms. Each BAR
207 * and the expansion ROM have a single line of data containing
208 * 3, 64-bit hex values: the first address in the region,
209 * the last address in the region, and the region's flags.
211 snprintf( name, 255, "%s/%04x:%02x:%02x.%1u/resource",
217 fd = open( name, O_RDONLY );
225 bytes = read( fd, resource, 512 );
226 resource[511] = '\0';
231 for ( i = 0 ; i < 6 ; i++ ) {
233 dev->regions[i].base_addr = strtoull( next, & next, 16 );
234 high_addr = strtoull( next, & next, 16 );
235 flags = strtoull( next, & next, 16 );
237 if ( dev->regions[i].base_addr != 0 ) {
238 dev->regions[i].size = (high_addr
239 - dev->regions[i].base_addr) + 1;
241 dev->regions[i].is_IO = (flags & 0x01);
242 dev->regions[i].is_64 = (flags & 0x04);
243 dev->regions[i].is_prefetchable = (flags & 0x08);
247 low_addr = strtoull( next, & next, 16 );
248 high_addr = strtoull( next, & next, 16 );
249 flags = strtoull( next, & next, 16 );
250 if ( low_addr != 0 ) {
251 dev->rom_size = (high_addr - low_addr) + 1;
261 pci_device_linux_sysfs_read_rom( struct pci_device * dev, void * buffer )
270 snprintf( name, 255, "%s/%04x:%02x:%02x.%1u/rom",
277 fd = open( name, O_RDWR );
283 if ( fstat( fd, & st ) == -1 ) {
289 /* This is a quirky thing on Linux. Even though the ROM and the file
290 * for the ROM in sysfs are read-only, the string "1" must be written to
291 * the file to enable the ROM. After the data has been read, "0" must be
292 * written to the file to disable the ROM.
295 lseek( fd, 0, SEEK_SET );
297 for ( total_bytes = 0 ; total_bytes < st.st_size ; /* empty */ ) {
298 const int bytes = read( fd, (char *) buffer + total_bytes,
299 st.st_size - total_bytes );
304 else if ( bytes == 0 ) {
308 total_bytes += bytes;
312 lseek( fd, 0, SEEK_SET );
321 pci_device_linux_sysfs_read( struct pci_device * dev, void * data,
322 pciaddr_t offset, pciaddr_t size,
323 pciaddr_t * bytes_read )
326 pciaddr_t temp_size = size;
331 if ( bytes_read != NULL ) {
335 /* Each device has a directory under sysfs. Within that directory there
336 * is a file named "config". This file used to access the PCI config
337 * space. It is used here to obtain most of the information about the
340 snprintf( name, 255, "%s/%04x:%02x:%02x.%1u/config",
347 fd = open( name, O_RDONLY );
353 while ( temp_size > 0 ) {
354 const ssize_t bytes = pread64( fd, data, temp_size, offset );
356 /* If zero bytes were read, then we assume it's the end of the
369 if ( bytes_read != NULL ) {
370 *bytes_read = size - temp_size;
379 pci_device_linux_sysfs_write( struct pci_device * dev, const void * data,
380 pciaddr_t offset, pciaddr_t size,
381 pciaddr_t * bytes_written )
384 pciaddr_t temp_size = size;
389 if ( bytes_written != NULL ) {
393 /* Each device has a directory under sysfs. Within that directory there
394 * is a file named "config". This file used to access the PCI config
395 * space. It is used here to obtain most of the information about the
398 snprintf( name, 255, "%s/%04x:%02x:%02x.%1u/config",
405 fd = open( name, O_WRONLY );
411 while ( temp_size > 0 ) {
412 const ssize_t bytes = pwrite64( fd, data, temp_size, offset );
414 /* If zero bytes were written, then we assume it's the end of the
427 if ( bytes_written != NULL ) {
428 *bytes_written = size - temp_size;
437 * Map a memory region for a device using the Linux sysfs interface.
439 * \param dev Device whose memory region is to be mapped.
440 * \param region Region, on the range [0, 5], that is to be mapped.
441 * \param write_enable Map for writing (non-zero).
444 * Zero on success or an \c errno value on failure.
446 * \sa pci_device_map_region, pci_device_linux_sysfs_unmap_region
449 * Some older 2.6.x kernels don't implement the resourceN files. On those
450 * systems /dev/mem must be used. On these systems it is also possible that
451 * \c mmap64 may need to be used.
454 pci_device_linux_sysfs_map_region( struct pci_device * dev, unsigned region,
460 const int prot = (write_enable) ? (PROT_READ | PROT_WRITE) : PROT_READ;
463 snprintf( name, 255, "%s/%04x:%02x:%02x.%1u/resource%u",
471 fd = open( name, (write_enable) ? O_RDWR : O_RDONLY );
477 dev->regions[ region ].memory = mmap( NULL, dev->regions[ region ].size,
478 prot, MAP_SHARED, fd, 0 );
479 if ( dev->regions[ region ].memory == MAP_FAILED ) {
481 dev->regions[ region ].memory = NULL;
490 * Unmap the specified region using the Linux sysfs interface.
492 * \param dev Device whose memory region is to be mapped.
493 * \param region Region, on the range [0, 5], that is to be mapped.
496 * Zero on success or an \c errno value on failure.
498 * \sa pci_device_unmap_region, pci_device_linux_sysfs_map_region
501 * Some older 2.6.x kernels don't implement the resourceN files. On those
502 * systems /dev/mem must be used. On these systems it is also possible that
503 * \c mmap64 may need to be used.
506 pci_device_linux_sysfs_unmap_region( struct pci_device * dev, unsigned region )
510 if ( munmap( dev->regions[ region ].memory, dev->regions[ region ].size )
515 dev->regions[ region ].memory = NULL;