1 /* 2 * (C) Copyright IBM Corporation 2006 3 * All Rights Reserved. 4 * 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: 11 * 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 14 * Software. 15 * 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. 23 */ 24 25 /** 26 * \file linux_sysfs.c 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. 30 * 31 * \author Ian Romanick <[email protected]> 32 */ 33 34 #define _GNU_SOURCE 35 36 #include <stdlib.h> 37 #include <string.h> 38 #include <stdio.h> 39 #include <unistd.h> 40 #include <sys/types.h> 41 #include <sys/stat.h> 42 #include <fcntl.h> 43 #include <sys/mman.h> 44 #include <dirent.h> 45 #include <errno.h> 46 47 #include "config.h" 48 49 #ifdef HAVE_MTRR 50 #include <asm/mtrr.h> 51 #include <sys/ioctl.h> 52 #endif 53 54 #include "pciaccess.h" 55 #include "pciaccess_private.h" 56 #include "linux_devmem.h" 57 58 static int pci_device_linux_sysfs_read_rom( struct pci_device * dev, 59 void * buffer ); 60 61 static int pci_device_linux_sysfs_probe( struct pci_device * dev ); 62 63 static int pci_device_linux_sysfs_map_range(struct pci_device *dev, 64 struct pci_device_mapping *map); 65 66 static int pci_device_linux_sysfs_unmap_range(struct pci_device *dev, 67 struct pci_device_mapping *map); 68 69 static int pci_device_linux_sysfs_read( struct pci_device * dev, void * data, 70 pciaddr_t offset, pciaddr_t size, pciaddr_t * bytes_read ); 71 72 static int pci_device_linux_sysfs_write( struct pci_device * dev, 73 const void * data, pciaddr_t offset, pciaddr_t size, 74 pciaddr_t * bytes_wrtten ); 75 76 static const struct pci_system_methods linux_sysfs_methods = { 77 .destroy = NULL, 78 .destroy_device = NULL, 79 .read_rom = pci_device_linux_sysfs_read_rom, 80 .probe = pci_device_linux_sysfs_probe, 81 .map_range = pci_device_linux_sysfs_map_range, 82 .unmap_range = pci_device_linux_sysfs_unmap_range, 83 84 .read = pci_device_linux_sysfs_read, 85 .write = pci_device_linux_sysfs_write, 86 87 .fill_capabilities = pci_fill_capabilities_generic 88 }; 89 90 #define SYS_BUS_PCI "/sys/bus/pci/devices" 91 92 93 static int populate_entries(struct pci_system * pci_sys); 94 95 96 /** 97 * Attempt to access PCI subsystem using Linux's sysfs interface. 98 */ 99 int 100 pci_system_linux_sysfs_create( void ) 101 { 102 int err = 0; 103 struct stat st; 104 105 106 /* If the directory "/sys/bus/pci/devices" exists, then the PCI subsystem 107 * can be accessed using this interface. 108 */ 109 110 if ( stat( SYS_BUS_PCI, & st ) == 0 ) { 111 pci_sys = calloc( 1, sizeof( struct pci_system ) ); 112 if ( pci_sys != NULL ) { 113 pci_sys->methods = & linux_sysfs_methods; 114 err = populate_entries(pci_sys); 115 } 116 else { 117 err = ENOMEM; 118 } 119 } 120 else { 121 err = errno; 122 } 123 124 #ifdef HAVE_MTRR 125 pci_sys->mtrr_fd = open("/proc/mtrr", O_WRONLY); 126 #endif 127 128 return err; 129 } 130 131 132 /** 133 * Filter out the names "." and ".." from the scanned sysfs entries. 134 * 135 * \param d Directory entry being processed by \c scandir. 136 * 137 * \return 138 * Zero if the entry name matches either "." or "..", non-zero otherwise. 139 * 140 * \sa scandir, populate_entries 141 */ 142 static int 143 scan_sys_pci_filter( const struct dirent * d ) 144 { 145 return !((strcmp( d->d_name, "." ) == 0) 146 || (strcmp( d->d_name, ".." ) == 0)); 147 } 148 149 150 int 151 populate_entries( struct pci_system * p ) 152 { 153 struct dirent ** devices; 154 int n; 155 int i; 156 int err = 0; 157 158 159 n = scandir( SYS_BUS_PCI, & devices, scan_sys_pci_filter, alphasort ); 160 if ( n > 0 ) { 161 p->num_devices = n; 162 p->devices = calloc( n, sizeof( struct pci_device_private ) ); 163 164 if (p->devices != NULL) { 165 for (i = 0 ; i < n ; i++) { 166 uint8_t config[48]; 167 pciaddr_t bytes; 168 unsigned dom, bus, dev, func; 169 struct pci_device_private *device = 170 (struct pci_device_private *) &p->devices[i]; 171 172 173 sscanf(devices[i]->d_name, "%04x:%02x:%02x.%1u", 174 & dom, & bus, & dev, & func); 175 176 device->base.domain = dom; 177 device->base.bus = bus; 178 device->base.dev = dev; 179 device->base.func = func; 180 181 182 err = pci_device_linux_sysfs_read(& device->base, config, 0, 183 48, & bytes); 184 if ((bytes == 48) && !err) { 185 device->base.vendor_id = (uint16_t)config[0] 186 + ((uint16_t)config[1] << 8); 187 device->base.device_id = (uint16_t)config[2] 188 + ((uint16_t)config[3] << 8); 189 device->base.device_class = (uint32_t)config[9] 190 + ((uint32_t)config[10] << 8) 191 + ((uint32_t)config[11] << 16); 192 device->base.revision = config[8]; 193 device->base.subvendor_id = (uint16_t)config[44] 194 + ((uint16_t)config[45] << 8); 195 device->base.subdevice_id = (uint16_t)config[46] 196 + ((uint16_t)config[47] << 8); 197 } 198 199 if (err) { 200 break; 201 } 202 } 203 } 204 else { 205 err = ENOMEM; 206 } 207 } 208 209 if (err) { 210 free(p->devices); 211 p->devices = NULL; 212 } 213 214 return err; 215 } 216 217 218 static int 219 pci_device_linux_sysfs_probe( struct pci_device * dev ) 220 { 221 char name[256]; 222 uint8_t config[256]; 223 char resource[512]; 224 int fd; 225 pciaddr_t bytes; 226 unsigned i; 227 int err; 228 229 230 err = pci_device_linux_sysfs_read( dev, config, 0, 256, & bytes ); 231 if ( bytes >= 64 ) { 232 struct pci_device_private *priv = (struct pci_device_private *) dev; 233 234 dev->irq = config[60]; 235 priv->header_type = config[14]; 236 237 238 /* The PCI config registers can be used to obtain information 239 * about the memory and I/O regions for the device. However, 240 * doing so requires some tricky parsing (to correctly handle 241 * 64-bit memory regions) and requires writing to the config 242 * registers. Since we'd like to avoid having to deal with the 243 * parsing issues and non-root users can write to PCI config 244 * registers, we use a different file in the device's sysfs 245 * directory called "resource". 246 * 247 * The resource file contains all of the needed information in 248 * a format that is consistent across all platforms. Each BAR 249 * and the expansion ROM have a single line of data containing 250 * 3, 64-bit hex values: the first address in the region, 251 * the last address in the region, and the region's flags. 252 */ 253 snprintf( name, 255, "%s/%04x:%02x:%02x.%1u/resource", 254 SYS_BUS_PCI, 255 dev->domain, 256 dev->bus, 257 dev->dev, 258 dev->func ); 259 fd = open( name, O_RDONLY ); 260 if ( fd != -1 ) { 261 char * next; 262 pciaddr_t low_addr; 263 pciaddr_t high_addr; 264 pciaddr_t flags; 265 266 267 bytes = read( fd, resource, 512 ); 268 resource[511] = '\0'; 269 270 close( fd ); 271 272 next = resource; 273 for ( i = 0 ; i < 6 ; i++ ) { 274 275 dev->regions[i].base_addr = strtoull( next, & next, 16 ); 276 high_addr = strtoull( next, & next, 16 ); 277 flags = strtoull( next, & next, 16 ); 278 279 if ( dev->regions[i].base_addr != 0 ) { 280 dev->regions[i].size = (high_addr 281 - dev->regions[i].base_addr) + 1; 282 283 dev->regions[i].is_IO = (flags & 0x01); 284 dev->regions[i].is_64 = (flags & 0x04); 285 dev->regions[i].is_prefetchable = (flags & 0x08); 286 } 287 } 288 289 low_addr = strtoull( next, & next, 16 ); 290 high_addr = strtoull( next, & next, 16 ); 291 flags = strtoull( next, & next, 16 ); 292 if ( low_addr != 0 ) { 293 priv->rom_base = low_addr; 294 dev->rom_size = (high_addr - low_addr) + 1; 295 } 296 } 297 } 298 299 return err; 300 } 301 302 303 static int 304 pci_device_linux_sysfs_read_rom( struct pci_device * dev, void * buffer ) 305 { 306 char name[256]; 307 int fd; 308 struct stat st; 309 int err = 0; 310 size_t total_bytes; 311 312 313 snprintf( name, 255, "%s/%04x:%02x:%02x.%1u/rom", 314 SYS_BUS_PCI, 315 dev->domain, 316 dev->bus, 317 dev->dev, 318 dev->func ); 319 320 fd = open( name, O_RDWR ); 321 if ( fd == -1 ) { 322 /* If reading the ROM using sysfs fails, fall back to the old 323 * /dev/mem based interface. 324 */ 325 return pci_device_linux_devmem_read_rom(dev, buffer); 326 } 327 328 329 if ( fstat( fd, & st ) == -1 ) { 330 close( fd ); 331 return errno; 332 } 333 334 335 /* This is a quirky thing on Linux. Even though the ROM and the file 336 * for the ROM in sysfs are read-only, the string "1" must be written to 337 * the file to enable the ROM. After the data has been read, "0" must be 338 * written to the file to disable the ROM. 339 */ 340 write( fd, "1", 1 ); 341 lseek( fd, 0, SEEK_SET ); 342 343 for ( total_bytes = 0 ; total_bytes < st.st_size ; /* empty */ ) { 344 const int bytes = read( fd, (char *) buffer + total_bytes, 345 st.st_size - total_bytes ); 346 if ( bytes == -1 ) { 347 err = errno; 348 break; 349 } 350 else if ( bytes == 0 ) { 351 break; 352 } 353 354 total_bytes += bytes; 355 } 356 357 358 lseek( fd, 0, SEEK_SET ); 359 write( fd, "0", 1 ); 360 361 close( fd ); 362 return err; 363 } 364 365 366 static int 367 pci_device_linux_sysfs_read( struct pci_device * dev, void * data, 368 pciaddr_t offset, pciaddr_t size, 369 pciaddr_t * bytes_read ) 370 { 371 char name[256]; 372 pciaddr_t temp_size = size; 373 int err = 0; 374 int fd; 375 char *data_bytes = data; 376 377 if ( bytes_read != NULL ) { 378 *bytes_read = 0; 379 } 380 381 /* Each device has a directory under sysfs. Within that directory there 382 * is a file named "config". This file used to access the PCI config 383 * space. It is used here to obtain most of the information about the 384 * device. 385 */ 386 snprintf( name, 255, "%s/%04x:%02x:%02x.%1u/config", 387 SYS_BUS_PCI, 388 dev->domain, 389 dev->bus, 390 dev->dev, 391 dev->func ); 392 393 fd = open( name, O_RDONLY ); 394 if ( fd == -1 ) { 395 return errno; 396 } 397 398 399 while ( temp_size > 0 ) { 400 const ssize_t bytes = pread64( fd, data_bytes, temp_size, offset ); 401 402 /* If zero bytes were read, then we assume it's the end of the 403 * config file. 404 */ 405 if ( bytes <= 0 ) { 406 err = errno; 407 break; 408 } 409 410 temp_size -= bytes; 411 offset += bytes; 412 data_bytes += bytes; 413 } 414 415 if ( bytes_read != NULL ) { 416 *bytes_read = size - temp_size; 417 } 418 419 close( fd ); 420 return err; 421 } 422 423 424 static int 425 pci_device_linux_sysfs_write( struct pci_device * dev, const void * data, 426 pciaddr_t offset, pciaddr_t size, 427 pciaddr_t * bytes_written ) 428 { 429 char name[256]; 430 pciaddr_t temp_size = size; 431 int err = 0; 432 int fd; 433 const char *data_bytes = data; 434 435 if ( bytes_written != NULL ) { 436 *bytes_written = 0; 437 } 438 439 /* Each device has a directory under sysfs. Within that directory there 440 * is a file named "config". This file used to access the PCI config 441 * space. It is used here to obtain most of the information about the 442 * device. 443 */ 444 snprintf( name, 255, "%s/%04x:%02x:%02x.%1u/config", 445 SYS_BUS_PCI, 446 dev->domain, 447 dev->bus, 448 dev->dev, 449 dev->func ); 450 451 fd = open( name, O_WRONLY ); 452 if ( fd == -1 ) { 453 return errno; 454 } 455 456 457 while ( temp_size > 0 ) { 458 const ssize_t bytes = pwrite64( fd, data_bytes, temp_size, offset ); 459 460 /* If zero bytes were written, then we assume it's the end of the 461 * config file. 462 */ 463 if ( bytes <= 0 ) { 464 err = errno; 465 break; 466 } 467 468 temp_size -= bytes; 469 offset += bytes; 470 data_bytes += bytes; 471 } 472 473 if ( bytes_written != NULL ) { 474 *bytes_written = size - temp_size; 475 } 476 477 close( fd ); 478 return err; 479 } 480 481 482 /** 483 * Map a memory region for a device using the Linux sysfs interface. 484 * 485 * \param dev Device whose memory region is to be mapped. 486 * \param map Parameters of the mapping that is to be created. 487 * 488 * \return 489 * Zero on success or an \c errno value on failure. 490 * 491 * \sa pci_device_map_rrange, pci_device_linux_sysfs_unmap_range 492 * 493 * \todo 494 * Some older 2.6.x kernels don't implement the resourceN files. On those 495 * systems /dev/mem must be used. On these systems it is also possible that 496 * \c mmap64 may need to be used. 497 */ 498 static int 499 pci_device_linux_sysfs_map_range(struct pci_device *dev, 500 struct pci_device_mapping *map) 501 { 502 char name[256]; 503 int fd; 504 int err = 0; 505 const int prot = ((map->flags & PCI_DEV_MAP_FLAG_WRITABLE) != 0) 506 ? (PROT_READ | PROT_WRITE) : PROT_READ; 507 const int open_flags = ((map->flags & PCI_DEV_MAP_FLAG_WRITABLE) != 0) 508 ? O_RDWR : O_RDONLY; 509 const off_t offset = map->base - dev->regions[map->region].base_addr; 510 #ifdef HAVE_MTRR 511 struct mtrr_sentry sentry = { 512 .base = map->base, 513 .size = map->size, 514 .type = MTRR_TYPE_UNCACHABLE 515 }; 516 #endif 517 518 snprintf(name, 255, "%s/%04x:%02x:%02x.%1u/resource%u", 519 SYS_BUS_PCI, 520 dev->domain, 521 dev->bus, 522 dev->dev, 523 dev->func, 524 map->region); 525 526 fd = open(name, open_flags); 527 if (fd == -1) { 528 return errno; 529 } 530 531 532 map->memory = mmap(NULL, map->size, prot, MAP_SHARED, fd, offset); 533 if (map->memory == MAP_FAILED) { 534 err = errno; 535 map->memory = NULL; 536 } 537 538 close(fd); 539 540 #ifdef HAVE_MTRR 541 if ((map->flags & PCI_DEV_MAP_FLAG_CACHABLE) != 0) { 542 sentry.type = MTRR_TYPE_WRBACK; 543 } else if ((map->flags & PCI_DEV_MAP_FLAG_WRITE_COMBINE) != 0) { 544 sentry.type = MTRR_TYPE_WRCOMB; 545 } 546 547 if (pci_sys->mtrr_fd != -1 && sentry.type != MTRR_TYPE_UNCACHABLE) { 548 if (ioctl(pci_sys->mtrr_fd, MTRRIOC_ADD_ENTRY, &sentry) < 0) { 549 /* FIXME: Should we report an error in this case? 550 */ 551 fprintf(stderr, "error setting MTRR " 552 "(base = 0x%08lx, size = 0x%08x, type = %u) %s (%d)\n", 553 sentry.base, sentry.size, sentry.type, 554 strerror(errno), errno); 555 /* err = errno;*/ 556 } 557 } 558 #endif 559 560 return err; 561 } 562 563 /** 564 * Unmap a memory region for a device using the Linux sysfs interface. 565 * 566 * \param dev Device whose memory region is to be unmapped. 567 * \param map Parameters of the mapping that is to be destroyed. 568 * 569 * \return 570 * Zero on success or an \c errno value on failure. 571 * 572 * \sa pci_device_map_rrange, pci_device_linux_sysfs_map_range 573 * 574 * \todo 575 * Some older 2.6.x kernels don't implement the resourceN files. On those 576 * systems /dev/mem must be used. On these systems it is also possible that 577 * \c mmap64 may need to be used. 578 */ 579 static int 580 pci_device_linux_sysfs_unmap_range(struct pci_device *dev, 581 struct pci_device_mapping *map) 582 { 583 int err = 0; 584 #ifdef HAVE_MTRR 585 struct mtrr_sentry sentry = { 586 .base = map->base, 587 .size = map->size, 588 .type = MTRR_TYPE_UNCACHABLE 589 }; 590 #endif 591 592 err = pci_device_generic_unmap_range (dev, map); 593 if (err) 594 return err; 595 596 #ifdef HAVE_MTRR 597 if ((map->flags & PCI_DEV_MAP_FLAG_CACHABLE) != 0) { 598 sentry.type = MTRR_TYPE_WRBACK; 599 } else if ((map->flags & PCI_DEV_MAP_FLAG_WRITE_COMBINE) != 0) { 600 sentry.type = MTRR_TYPE_WRCOMB; 601 } 602 603 if (pci_sys->mtrr_fd != -1 && sentry.type != MTRR_TYPE_UNCACHABLE) { 604 if (ioctl(pci_sys->mtrr_fd, MTRRIOC_DEL_ENTRY, &sentry) < 0) { 605 /* FIXME: Should we report an error in this case? 606 */ 607 fprintf(stderr, "error setting MTRR " 608 "(base = 0x%08lx, size = 0x%08x, type = %u) %s (%d)\n", 609 sentry.base, sentry.size, sentry.type, 610 strerror(errno), errno); 611 /* err = errno;*/ 612 } 613 } 614 #endif 615 616 return err; 617 } 618